| // DO NOT EDIT! This file generated by scripts/gen-s-parser.py |
| |
| // clang-format off |
| |
| // NOLINTBEGIN |
| |
| auto op = *keyword; |
| char buf[33] = {}; |
| // Ensure we do not copy more than the buffer can hold |
| if (op.size() >= sizeof(buf)) { |
| goto parse_error; |
| } |
| memcpy(buf, op.data(), op.size()); |
| switch (buf[0]) { |
| case 'a': { |
| switch (buf[1]) { |
| case 'n': |
| if (op == "any.convert_extern"sv) { |
| CHECK_ERR(makeRefAs(ctx, pos, annotations, AnyConvertExtern)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[6]) { |
| case 'c': |
| if (op == "array.copy"sv) { |
| CHECK_ERR(makeArrayCopy(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'f': |
| if (op == "array.fill"sv) { |
| CHECK_ERR(makeArrayFill(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "array.get"sv) { |
| CHECK_ERR(makeArrayGet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "array.get_s"sv) { |
| CHECK_ERR(makeArrayGet(ctx, pos, annotations, true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "array.get_u"sv) { |
| CHECK_ERR(makeArrayGet(ctx, pos, annotations, false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'i': { |
| switch (buf[11]) { |
| case 'd': |
| if (op == "array.init_data"sv) { |
| CHECK_ERR(makeArrayInitData(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': |
| if (op == "array.init_elem"sv) { |
| CHECK_ERR(makeArrayInitElem(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': |
| if (op == "array.len"sv) { |
| CHECK_ERR(makeArrayLen(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "array.new"sv) { |
| CHECK_ERR(makeArrayNew(ctx, pos, annotations, false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[10]) { |
| case 'd': { |
| switch (buf[11]) { |
| case 'a': |
| if (op == "array.new_data"sv) { |
| CHECK_ERR(makeArrayNewData(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': |
| if (op == "array.new_default"sv) { |
| CHECK_ERR(makeArrayNew(ctx, pos, annotations, true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': |
| if (op == "array.new_elem"sv) { |
| CHECK_ERR(makeArrayNewElem(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'f': |
| if (op == "array.new_fixed"sv) { |
| CHECK_ERR(makeArrayNewFixed(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 's': |
| if (op == "array.set"sv) { |
| CHECK_ERR(makeArraySet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': |
| if (op == "atomic.fence"sv) { |
| CHECK_ERR(makeAtomicFence(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'b': { |
| switch (buf[2]) { |
| case '\0': |
| if (op == "br"sv) { |
| CHECK_ERR(makeBreak(ctx, pos, annotations, false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[3]) { |
| case 'i': |
| if (op == "br_if"sv) { |
| CHECK_ERR(makeBreak(ctx, pos, annotations, true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': { |
| switch (buf[6]) { |
| case 'c': { |
| switch (buf[10]) { |
| case '\0': |
| if (op == "br_on_cast"sv) { |
| CHECK_ERR(makeBrOnCast(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': |
| if (op == "br_on_cast_fail"sv) { |
| CHECK_ERR(makeBrOnCast(ctx, pos, annotations, true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[7]) { |
| case 'o': |
| if (op == "br_on_non_null"sv) { |
| CHECK_ERR(makeBrOnNull(ctx, pos, annotations, true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "br_on_null"sv) { |
| CHECK_ERR(makeBrOnNull(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 't': |
| if (op == "br_table"sv) { |
| CHECK_ERR(makeBreakTable(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'c': { |
| switch (buf[1]) { |
| case 'a': { |
| switch (buf[4]) { |
| case '\0': |
| if (op == "call"sv) { |
| CHECK_ERR(makeCall(ctx, pos, annotations, /*isReturn=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[5]) { |
| case 'i': |
| if (op == "call_indirect"sv) { |
| CHECK_ERR(makeCallIndirect(ctx, pos, annotations, /*isReturn=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': |
| if (op == "call_ref"sv) { |
| CHECK_ERR(makeCallRef(ctx, pos, annotations, /*isReturn=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'o': { |
| switch (buf[5]) { |
| case 'b': |
| if (op == "cont.bind"sv) { |
| CHECK_ERR(makeContBind(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "cont.new"sv) { |
| CHECK_ERR(makeContNew(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'd': { |
| switch (buf[1]) { |
| case 'a': |
| if (op == "data.drop"sv) { |
| CHECK_ERR(makeDataDrop(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': |
| if (op == "drop"sv) { |
| CHECK_ERR(makeDrop(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[7]) { |
| case 'c': |
| if (op == "extern.convert_any"sv) { |
| CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternConvertAny)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': |
| if (op == "extern.externalize"sv) { |
| CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternConvertAny)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "extern.internalize"sv) { |
| CHECK_ERR(makeRefAs(ctx, pos, annotations, AnyConvertExtern)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'f': { |
| switch (buf[1]) { |
| case '1': { |
| switch (buf[6]) { |
| case 'a': { |
| switch (buf[7]) { |
| case 'b': |
| if (op == "f16x8.abs"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': |
| if (op == "f16x8.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f16x8.ceil"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': { |
| switch (buf[20]) { |
| case 's': |
| if (op == "f16x8.convert_i16x8_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSVecI16x8ToVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f16x8.convert_i16x8_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUVecI16x8ToVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'd': |
| if (op == "f16x8.div"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': { |
| switch (buf[7]) { |
| case 'q': |
| if (op == "f16x8.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': |
| if (op == "f16x8.extract_lane"sv) { |
| CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecF16x8, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'f': |
| if (op == "f16x8.floor"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f16x8.ge"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f16x8.gt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f16x8.le"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f16x8.lt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[7]) { |
| case 'a': |
| if (op == "f16x8.max"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f16x8.min"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f16x8.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "f16x8.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'a': |
| if (op == "f16x8.nearest"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "f16x8.neg"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'p': { |
| switch (buf[8]) { |
| case 'a': |
| if (op == "f16x8.pmax"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMaxVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f16x8.pmin"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMinVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'r': { |
| switch (buf[8]) { |
| case 'l': { |
| switch (buf[14]) { |
| case 'm': |
| if (op == "f16x8.relaxed_madd"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedMaddVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "f16x8.relaxed_nmadd"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedNmaddVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "f16x8.replace_lane"sv) { |
| CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecF16x8, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[7]) { |
| case 'p': |
| if (op == "f16x8.splat"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'q': |
| if (op == "f16x8.sqrt"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f16x8.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': |
| if (op == "f16x8.trunc"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncVecF16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '3': { |
| switch (buf[3]) { |
| case '.': { |
| switch (buf[4]) { |
| case 'a': { |
| switch (buf[5]) { |
| case 'b': |
| if (op == "f32.abs"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': |
| if (op == "f32.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': { |
| switch (buf[5]) { |
| case 'e': |
| if (op == "f32.ceil"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': { |
| switch (buf[6]) { |
| case 'n': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "f32.const"sv) { |
| CHECK_ERR(makeConst(ctx, pos, annotations, Type::f32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'v': { |
| switch (buf[13]) { |
| case '3': { |
| switch (buf[16]) { |
| case 's': |
| if (op == "f32.convert_i32_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSInt32ToFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f32.convert_i32_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUInt32ToFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[16]) { |
| case 's': |
| if (op == "f32.convert_i64_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSInt64ToFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f32.convert_i64_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUInt64ToFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "f32.copysign"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::CopySignFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'd': { |
| switch (buf[5]) { |
| case 'e': |
| if (op == "f32.demote_f64"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::DemoteFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f32.div"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': |
| if (op == "f32.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'f': |
| if (op == "f32.floor"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': { |
| switch (buf[5]) { |
| case 'e': |
| if (op == "f32.ge"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f32.gt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[5]) { |
| case 'e': |
| if (op == "f32.le"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "f32.load"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::f32, /*signed=*/false, 4, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': |
| if (op == "f32.load_f16"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::f32, /*signed=*/false, 2, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': |
| if (op == "f32.lt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[5]) { |
| case 'a': |
| if (op == "f32.max"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f32.min"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f32.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[6]) { |
| case '\0': |
| if (op == "f32.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'a': |
| if (op == "f32.nearest"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "f32.neg"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'r': |
| if (op == "f32.reinterpret_i32"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ReinterpretInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': { |
| switch (buf[5]) { |
| case 'q': |
| if (op == "f32.sqrt"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "f32.store"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::f32, 4, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': |
| if (op == "f32.store_f16"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::f32, 2, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'u': |
| if (op == "f32.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': |
| if (op == "f32.trunc"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': { |
| switch (buf[6]) { |
| case 'a': { |
| switch (buf[7]) { |
| case 'b': |
| if (op == "f32x4.abs"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': |
| if (op == "f32x4.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f32x4.ceil"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': { |
| switch (buf[20]) { |
| case 's': |
| if (op == "f32x4.convert_i32x4_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSVecI32x4ToVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f32x4.convert_i32x4_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUVecI32x4ToVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'd': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f32x4.demote_f64x2_zero"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::DemoteZeroVecF64x2ToVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f32x4.div"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[7]) { |
| case 'q': |
| if (op == "f32x4.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': |
| if (op == "f32x4.extract_lane"sv) { |
| CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecF32x4, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'f': |
| if (op == "f32x4.floor"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f32x4.ge"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f32x4.gt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f32x4.le"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f32x4.lt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[7]) { |
| case 'a': |
| if (op == "f32x4.max"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f32x4.min"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f32x4.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "f32x4.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'a': |
| if (op == "f32x4.nearest"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "f32x4.neg"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'p': { |
| switch (buf[8]) { |
| case 'a': |
| if (op == "f32x4.pmax"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMaxVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f32x4.pmin"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMinVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'r': { |
| switch (buf[8]) { |
| case 'l': { |
| switch (buf[14]) { |
| case 'm': { |
| switch (buf[15]) { |
| case 'a': { |
| switch (buf[16]) { |
| case 'd': |
| if (op == "f32x4.relaxed_madd"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedMaddVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': |
| if (op == "f32x4.relaxed_max"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedMaxVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'i': |
| if (op == "f32x4.relaxed_min"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedMinVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': |
| if (op == "f32x4.relaxed_nmadd"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedNmaddVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "f32x4.replace_lane"sv) { |
| CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecF32x4, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[7]) { |
| case 'p': |
| if (op == "f32x4.splat"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'q': |
| if (op == "f32x4.sqrt"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f32x4.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': |
| if (op == "f32x4.trunc"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncVecF32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[3]) { |
| case '.': { |
| switch (buf[4]) { |
| case 'a': { |
| switch (buf[5]) { |
| case 'b': |
| if (op == "f64.abs"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': |
| if (op == "f64.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': { |
| switch (buf[5]) { |
| case 'e': |
| if (op == "f64.ceil"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': { |
| switch (buf[6]) { |
| case 'n': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "f64.const"sv) { |
| CHECK_ERR(makeConst(ctx, pos, annotations, Type::f64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'v': { |
| switch (buf[13]) { |
| case '3': { |
| switch (buf[16]) { |
| case 's': |
| if (op == "f64.convert_i32_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSInt32ToFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f64.convert_i32_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUInt32ToFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[16]) { |
| case 's': |
| if (op == "f64.convert_i64_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertSInt64ToFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f64.convert_i64_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertUInt64ToFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "f64.copysign"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::CopySignFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'd': |
| if (op == "f64.div"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': |
| if (op == "f64.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'f': |
| if (op == "f64.floor"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': { |
| switch (buf[5]) { |
| case 'e': |
| if (op == "f64.ge"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f64.gt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[5]) { |
| case 'e': |
| if (op == "f64.le"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "f64.load"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::f64, /*signed=*/false, 8, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f64.lt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[5]) { |
| case 'a': |
| if (op == "f64.max"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f64.min"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f64.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[6]) { |
| case '\0': |
| if (op == "f64.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'a': |
| if (op == "f64.nearest"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "f64.neg"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "f64.promote_f32"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PromoteFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': |
| if (op == "f64.reinterpret_i64"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ReinterpretInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': { |
| switch (buf[5]) { |
| case 'q': |
| if (op == "f64.sqrt"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f64.store"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::f64, 8, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f64.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': |
| if (op == "f64.trunc"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': { |
| switch (buf[6]) { |
| case 'a': { |
| switch (buf[7]) { |
| case 'b': |
| if (op == "f64x2.abs"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': |
| if (op == "f64x2.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f64x2.ceil"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CeilVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': { |
| switch (buf[24]) { |
| case 's': |
| if (op == "f64x2.convert_low_i32x4_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertLowSVecI32x4ToVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f64x2.convert_low_i32x4_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ConvertLowUVecI32x4ToVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'd': |
| if (op == "f64x2.div"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': { |
| switch (buf[7]) { |
| case 'q': |
| if (op == "f64x2.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': |
| if (op == "f64x2.extract_lane"sv) { |
| CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecF64x2, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'f': |
| if (op == "f64x2.floor"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::FloorVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f64x2.ge"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f64x2.gt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "f64x2.le"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "f64x2.lt"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[7]) { |
| case 'a': |
| if (op == "f64x2.max"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f64x2.min"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f64x2.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "f64x2.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'a': |
| if (op == "f64x2.nearest"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NearestVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "f64x2.neg"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'p': { |
| switch (buf[7]) { |
| case 'm': { |
| switch (buf[8]) { |
| case 'a': |
| if (op == "f64x2.pmax"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMaxVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "f64x2.pmin"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::PMinVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'r': |
| if (op == "f64x2.promote_low_f32x4"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PromoteLowVecF32x4ToVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'r': { |
| switch (buf[8]) { |
| case 'l': { |
| switch (buf[14]) { |
| case 'm': { |
| switch (buf[15]) { |
| case 'a': { |
| switch (buf[16]) { |
| case 'd': |
| if (op == "f64x2.relaxed_madd"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedMaddVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': |
| if (op == "f64x2.relaxed_max"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedMaxVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'i': |
| if (op == "f64x2.relaxed_min"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedMinVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': |
| if (op == "f64x2.relaxed_nmadd"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::RelaxedNmaddVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "f64x2.replace_lane"sv) { |
| CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecF64x2, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[7]) { |
| case 'p': |
| if (op == "f64x2.splat"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'q': |
| if (op == "f64x2.sqrt"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SqrtVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "f64x2.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': |
| if (op == "f64x2.trunc"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncVecF64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'g': { |
| switch (buf[7]) { |
| case 'g': |
| if (op == "global.get"sv) { |
| CHECK_ERR(makeGlobalGet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "global.set"sv) { |
| CHECK_ERR(makeGlobalSet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'i': { |
| switch (buf[1]) { |
| case '1': { |
| switch (buf[6]) { |
| case 'a': { |
| switch (buf[7]) { |
| case 'b': |
| if (op == "i16x8.abs"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "i16x8.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "i16x8.add_sat_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddSatSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.add_sat_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddSatUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'l': |
| if (op == "i16x8.all_true"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AllTrueVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'v': |
| if (op == "i16x8.avgr_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AvgrUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'b': |
| if (op == "i16x8.bitmask"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::BitmaskVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': |
| if (op == "i16x8.dot_i8x16_i7x16_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DotI8x16I7x16SToVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': { |
| switch (buf[7]) { |
| case 'q': |
| if (op == "i16x8.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[9]) { |
| case 'a': { |
| switch (buf[28]) { |
| case 's': |
| if (op == "i16x8.extadd_pairwise_i8x16_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtAddPairwiseSVecI8x16ToI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.extadd_pairwise_i8x16_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtAddPairwiseUVecI8x16ToI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[13]) { |
| case 'h': { |
| switch (buf[24]) { |
| case 's': |
| if (op == "i16x8.extend_high_i8x16_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighSVecI8x16ToVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.extend_high_i8x16_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighUVecI8x16ToVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[23]) { |
| case 's': |
| if (op == "i16x8.extend_low_i8x16_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowSVecI8x16ToVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.extend_low_i8x16_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowUVecI8x16ToVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[13]) { |
| case 'h': { |
| switch (buf[24]) { |
| case 's': |
| if (op == "i16x8.extmul_high_i8x16_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.extmul_high_i8x16_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[23]) { |
| case 's': |
| if (op == "i16x8.extmul_low_i8x16_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.extmul_low_i8x16_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'r': { |
| switch (buf[19]) { |
| case 's': |
| if (op == "i16x8.extract_lane_s"sv) { |
| CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneSVecI16x8, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.extract_lane_u"sv) { |
| CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneUVecI16x8, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'g': { |
| switch (buf[7]) { |
| case 'e': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i16x8.ge_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.ge_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i16x8.gt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.gt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[7]) { |
| case 'a': |
| if (op == "i16x8.laneselect"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::LaneselectI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i16x8.le_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.le_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i16x8.lt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.lt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[7]) { |
| case 'a': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i16x8.max_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.max_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'i': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i16x8.min_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.min_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'u': |
| if (op == "i16x8.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[7]) { |
| case 'a': { |
| switch (buf[19]) { |
| case 's': |
| if (op == "i16x8.narrow_i32x4_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NarrowSVecI32x4ToVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.narrow_i32x4_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NarrowUVecI32x4ToVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "i16x8.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "i16x8.neg"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'q': |
| if (op == "i16x8.q15mulr_sat_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::Q15MulrSatSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[8]) { |
| case 'l': |
| if (op == "i16x8.relaxed_q15mulr_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedQ15MulrSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'p': |
| if (op == "i16x8.replace_lane"sv) { |
| CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecI16x8, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[7]) { |
| case 'h': { |
| switch (buf[8]) { |
| case 'l': |
| if (op == "i16x8.shl"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShlVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i16x8.shr_s"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.shr_u"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "i16x8.splat"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "i16x8.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "i16x8.sub_sat_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubSatSVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.sub_sat_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubSatUVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[22]) { |
| case 's': |
| if (op == "i16x8.trunc_sat_f16x8_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSVecF16x8ToVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i16x8.trunc_sat_f16x8_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUVecF16x8ToVecI16x8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '3': { |
| switch (buf[2]) { |
| case '1': { |
| switch (buf[8]) { |
| case 's': |
| if (op == "i31.get_s"sv) { |
| CHECK_ERR(makeI31Get(ctx, pos, annotations, true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i31.get_u"sv) { |
| CHECK_ERR(makeI31Get(ctx, pos, annotations, false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '2': { |
| switch (buf[3]) { |
| case '.': { |
| switch (buf[4]) { |
| case 'a': { |
| switch (buf[5]) { |
| case 'd': |
| if (op == "i32.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i32.and"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AndInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': { |
| switch (buf[11]) { |
| case 'l': { |
| switch (buf[15]) { |
| case '\0': |
| if (op == "i32.atomic.load"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 4, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': |
| if (op == "i32.atomic.load16_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 2, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "i32.atomic.load8_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 1, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'r': { |
| switch (buf[14]) { |
| case '.': { |
| switch (buf[15]) { |
| case 'a': { |
| switch (buf[16]) { |
| case 'd': |
| if (op == "i32.atomic.rmw.add"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i32, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i32.atomic.rmw.and"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i32, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': |
| if (op == "i32.atomic.rmw.cmpxchg"sv) { |
| CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i32, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i32.atomic.rmw.or"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i32, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "i32.atomic.rmw.sub"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i32, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[16]) { |
| case 'c': |
| if (op == "i32.atomic.rmw.xchg"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i32, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i32.atomic.rmw.xor"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i32, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '1': { |
| switch (buf[17]) { |
| case 'a': { |
| switch (buf[18]) { |
| case 'd': |
| if (op == "i32.atomic.rmw16.add_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i32, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i32.atomic.rmw16.and_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i32, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': |
| if (op == "i32.atomic.rmw16.cmpxchg_u"sv) { |
| CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i32, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i32.atomic.rmw16.or_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i32, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "i32.atomic.rmw16.sub_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i32, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[18]) { |
| case 'c': |
| if (op == "i32.atomic.rmw16.xchg_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i32, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i32.atomic.rmw16.xor_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i32, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '8': { |
| switch (buf[16]) { |
| case 'a': { |
| switch (buf[17]) { |
| case 'd': |
| if (op == "i32.atomic.rmw8.add_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i32, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i32.atomic.rmw8.and_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i32, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': |
| if (op == "i32.atomic.rmw8.cmpxchg_u"sv) { |
| CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i32, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i32.atomic.rmw8.or_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i32, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "i32.atomic.rmw8.sub_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i32, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[17]) { |
| case 'c': |
| if (op == "i32.atomic.rmw8.xchg_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i32, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i32.atomic.rmw8.xor_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i32, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[16]) { |
| case '\0': |
| if (op == "i32.atomic.store"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 4, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': |
| if (op == "i32.atomic.store16"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 2, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "i32.atomic.store8"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 1, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'c': { |
| switch (buf[5]) { |
| case 'l': |
| if (op == "i32.clz"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ClzInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i32.const"sv) { |
| CHECK_ERR(makeConst(ctx, pos, annotations, Type::i32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "i32.ctz"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CtzInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'd': { |
| switch (buf[8]) { |
| case 's': |
| if (op == "i32.div_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivSInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.div_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivUInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[5]) { |
| case 'q': { |
| switch (buf[6]) { |
| case '\0': |
| if (op == "i32.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'z': |
| if (op == "i32.eqz"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::EqZInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': { |
| switch (buf[10]) { |
| case '1': |
| if (op == "i32.extend16_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS16Int32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "i32.extend8_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS8Int32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'g': { |
| switch (buf[5]) { |
| case 'e': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "i32.ge_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.ge_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "i32.gt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.gt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[5]) { |
| case 'e': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "i32.le_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.le_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'o': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "i32.load"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 4, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': { |
| switch (buf[11]) { |
| case 's': |
| if (op == "i32.load16_s"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/true, 2, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.load16_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 2, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '8': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i32.load8_s"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/true, 1, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.load8_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i32, /*signed=*/false, 1, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "i32.lt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.lt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'm': |
| if (op == "i32.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i32.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i32.or"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::OrInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'p': |
| if (op == "i32.popcnt"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PopcntInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[5]) { |
| case 'e': { |
| switch (buf[6]) { |
| case 'i': |
| if (op == "i32.reinterpret_f32"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ReinterpretFloat32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'm': { |
| switch (buf[8]) { |
| case 's': |
| if (op == "i32.rem_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RemSInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.rem_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RemUInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'o': { |
| switch (buf[7]) { |
| case 'l': |
| if (op == "i32.rotl"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RotLInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': |
| if (op == "i32.rotr"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RotRInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[5]) { |
| case 'h': { |
| switch (buf[6]) { |
| case 'l': |
| if (op == "i32.shl"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShlInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[8]) { |
| case 's': |
| if (op == "i32.shr_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShrSInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.shr_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShrUInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "i32.store"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 4, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': |
| if (op == "i32.store16"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 2, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "i32.store8"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i32, 1, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'u': |
| if (op == "i32.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[10]) { |
| case 'f': { |
| switch (buf[11]) { |
| case '3': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "i32.trunc_f32_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSFloat32ToInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.trunc_f32_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncUFloat32ToInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "i32.trunc_f64_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSFloat64ToInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.trunc_f64_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncUFloat64ToInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[15]) { |
| case '3': { |
| switch (buf[18]) { |
| case 's': |
| if (op == "i32.trunc_sat_f32_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSFloat32ToInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.trunc_sat_f32_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUFloat32ToInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[18]) { |
| case 's': |
| if (op == "i32.trunc_sat_f64_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSFloat64ToInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32.trunc_sat_f64_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUFloat64ToInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'w': |
| if (op == "i32.wrap_i64"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::WrapInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': |
| if (op == "i32.xor"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::XorInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': { |
| switch (buf[6]) { |
| case 'a': { |
| switch (buf[7]) { |
| case 'b': |
| if (op == "i32x4.abs"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': |
| if (op == "i32x4.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'l': |
| if (op == "i32x4.all_true"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AllTrueVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'b': |
| if (op == "i32x4.bitmask"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::BitmaskVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': { |
| switch (buf[11]) { |
| case '1': |
| if (op == "i32x4.dot_i16x8_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DotSVecI16x8ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "i32x4.dot_i8x16_i7x16_add_s"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::DotI8x16I7x16AddSToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[7]) { |
| case 'q': |
| if (op == "i32x4.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[9]) { |
| case 'a': { |
| switch (buf[28]) { |
| case 's': |
| if (op == "i32x4.extadd_pairwise_i16x8_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtAddPairwiseSVecI16x8ToI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.extadd_pairwise_i16x8_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtAddPairwiseUVecI16x8ToI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[13]) { |
| case 'h': { |
| switch (buf[24]) { |
| case 's': |
| if (op == "i32x4.extend_high_i16x8_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighSVecI16x8ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.extend_high_i16x8_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighUVecI16x8ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[23]) { |
| case 's': |
| if (op == "i32x4.extend_low_i16x8_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowSVecI16x8ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.extend_low_i16x8_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowUVecI16x8ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[13]) { |
| case 'h': { |
| switch (buf[24]) { |
| case 's': |
| if (op == "i32x4.extmul_high_i16x8_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighSVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.extmul_high_i16x8_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighUVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[23]) { |
| case 's': |
| if (op == "i32x4.extmul_low_i16x8_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowSVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.extmul_low_i16x8_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowUVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'r': |
| if (op == "i32x4.extract_lane"sv) { |
| CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecI32x4, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'g': { |
| switch (buf[7]) { |
| case 'e': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i32x4.ge_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.ge_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i32x4.gt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.gt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[7]) { |
| case 'a': |
| if (op == "i32x4.laneselect"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::LaneselectI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i32x4.le_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.le_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i32x4.lt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.lt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[7]) { |
| case 'a': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i32x4.max_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxSVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.max_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxUVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'i': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i32x4.min_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinSVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.min_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinUVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'u': |
| if (op == "i32x4.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "i32x4.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "i32x4.neg"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'r': { |
| switch (buf[8]) { |
| case 'l': { |
| switch (buf[21]) { |
| case '3': { |
| switch (buf[26]) { |
| case 's': |
| if (op == "i32x4.relaxed_trunc_f32x4_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::RelaxedTruncSVecF32x4ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.relaxed_trunc_f32x4_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::RelaxedTruncUVecF32x4ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[26]) { |
| case 's': |
| if (op == "i32x4.relaxed_trunc_f64x2_s_zero"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::RelaxedTruncZeroSVecF64x2ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.relaxed_trunc_f64x2_u_zero"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::RelaxedTruncZeroUVecF64x2ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "i32x4.replace_lane"sv) { |
| CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecI32x4, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[7]) { |
| case 'h': { |
| switch (buf[8]) { |
| case 'l': |
| if (op == "i32x4.shl"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShlVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i32x4.shr_s"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrSVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.shr_u"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrUVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "i32x4.splat"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[17]) { |
| case '3': { |
| switch (buf[22]) { |
| case 's': |
| if (op == "i32x4.trunc_sat_f32x4_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSVecF32x4ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.trunc_sat_f32x4_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUVecF32x4ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[22]) { |
| case 's': |
| if (op == "i32x4.trunc_sat_f64x2_s_zero"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatZeroSVecF64x2ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i32x4.trunc_sat_f64x2_u_zero"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatZeroUVecF64x2ToVecI32x4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[3]) { |
| case '.': { |
| switch (buf[4]) { |
| case 'a': { |
| switch (buf[5]) { |
| case 'd': |
| if (op == "i64.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i64.and"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AndInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': { |
| switch (buf[11]) { |
| case 'l': { |
| switch (buf[15]) { |
| case '\0': |
| if (op == "i64.atomic.load"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 8, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': |
| if (op == "i64.atomic.load16_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 2, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '3': |
| if (op == "i64.atomic.load32_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 4, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "i64.atomic.load8_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 1, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'r': { |
| switch (buf[14]) { |
| case '.': { |
| switch (buf[15]) { |
| case 'a': { |
| switch (buf[16]) { |
| case 'd': |
| if (op == "i64.atomic.rmw.add"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i64, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i64.atomic.rmw.and"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i64, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': |
| if (op == "i64.atomic.rmw.cmpxchg"sv) { |
| CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i64, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.atomic.rmw.or"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i64, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "i64.atomic.rmw.sub"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i64, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[16]) { |
| case 'c': |
| if (op == "i64.atomic.rmw.xchg"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i64, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.atomic.rmw.xor"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i64, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '1': { |
| switch (buf[17]) { |
| case 'a': { |
| switch (buf[18]) { |
| case 'd': |
| if (op == "i64.atomic.rmw16.add_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i64, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i64.atomic.rmw16.and_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i64, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': |
| if (op == "i64.atomic.rmw16.cmpxchg_u"sv) { |
| CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i64, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.atomic.rmw16.or_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i64, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "i64.atomic.rmw16.sub_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i64, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[18]) { |
| case 'c': |
| if (op == "i64.atomic.rmw16.xchg_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i64, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.atomic.rmw16.xor_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i64, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '3': { |
| switch (buf[17]) { |
| case 'a': { |
| switch (buf[18]) { |
| case 'd': |
| if (op == "i64.atomic.rmw32.add_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i64, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i64.atomic.rmw32.and_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i64, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': |
| if (op == "i64.atomic.rmw32.cmpxchg_u"sv) { |
| CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i64, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.atomic.rmw32.or_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i64, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "i64.atomic.rmw32.sub_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i64, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[18]) { |
| case 'c': |
| if (op == "i64.atomic.rmw32.xchg_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i64, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.atomic.rmw32.xor_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i64, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '8': { |
| switch (buf[16]) { |
| case 'a': { |
| switch (buf[17]) { |
| case 'd': |
| if (op == "i64.atomic.rmw8.add_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAdd, Type::i64, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i64.atomic.rmw8.and_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWAnd, Type::i64, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'c': |
| if (op == "i64.atomic.rmw8.cmpxchg_u"sv) { |
| CHECK_ERR(makeAtomicCmpxchg(ctx, pos, annotations, Type::i64, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.atomic.rmw8.or_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWOr, Type::i64, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "i64.atomic.rmw8.sub_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWSub, Type::i64, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[17]) { |
| case 'c': |
| if (op == "i64.atomic.rmw8.xchg_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXchg, Type::i64, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.atomic.rmw8.xor_u"sv) { |
| CHECK_ERR(makeAtomicRMW(ctx, pos, annotations, AtomicRMWOp::RMWXor, Type::i64, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[16]) { |
| case '\0': |
| if (op == "i64.atomic.store"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 8, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': |
| if (op == "i64.atomic.store16"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 2, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '3': |
| if (op == "i64.atomic.store32"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 4, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "i64.atomic.store8"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 1, /*isAtomic=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'c': { |
| switch (buf[5]) { |
| case 'l': |
| if (op == "i64.clz"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ClzInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.const"sv) { |
| CHECK_ERR(makeConst(ctx, pos, annotations, Type::i64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "i64.ctz"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::CtzInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'd': { |
| switch (buf[8]) { |
| case 's': |
| if (op == "i64.div_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivSInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.div_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::DivUInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[5]) { |
| case 'q': { |
| switch (buf[6]) { |
| case '\0': |
| if (op == "i64.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'z': |
| if (op == "i64.eqz"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::EqZInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': { |
| switch (buf[10]) { |
| case '1': |
| if (op == "i64.extend16_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS16Int64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '3': |
| if (op == "i64.extend32_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS32Int64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "i64.extend8_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendS8Int64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[15]) { |
| case 's': |
| if (op == "i64.extend_i32_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendSInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.extend_i32_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendUInt32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'g': { |
| switch (buf[5]) { |
| case 'e': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "i64.ge_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.ge_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "i64.gt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.gt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[5]) { |
| case 'e': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "i64.le_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.le_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'o': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "i64.load"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 8, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': { |
| switch (buf[11]) { |
| case 's': |
| if (op == "i64.load16_s"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/true, 2, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.load16_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 2, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '3': { |
| switch (buf[11]) { |
| case 's': |
| if (op == "i64.load32_s"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/true, 4, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.load32_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 4, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '8': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i64.load8_s"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/true, 1, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.load8_u"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::i64, /*signed=*/false, 1, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[7]) { |
| case 's': |
| if (op == "i64.lt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.lt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'm': |
| if (op == "i64.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "i64.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "i64.or"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::OrInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'p': |
| if (op == "i64.popcnt"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PopcntInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[5]) { |
| case 'e': { |
| switch (buf[6]) { |
| case 'i': |
| if (op == "i64.reinterpret_f64"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ReinterpretFloat64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'm': { |
| switch (buf[8]) { |
| case 's': |
| if (op == "i64.rem_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RemSInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.rem_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RemUInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'o': { |
| switch (buf[7]) { |
| case 'l': |
| if (op == "i64.rotl"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RotLInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': |
| if (op == "i64.rotr"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RotRInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[5]) { |
| case 'h': { |
| switch (buf[6]) { |
| case 'l': |
| if (op == "i64.shl"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShlInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[8]) { |
| case 's': |
| if (op == "i64.shr_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShrSInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.shr_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ShrUInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "i64.store"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 8, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': |
| if (op == "i64.store16"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 2, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '3': |
| if (op == "i64.store32"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 4, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "i64.store8"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::i64, 1, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'u': |
| if (op == "i64.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[10]) { |
| case 'f': { |
| switch (buf[11]) { |
| case '3': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "i64.trunc_f32_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSFloat32ToInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.trunc_f32_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncUFloat32ToInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "i64.trunc_f64_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSFloat64ToInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.trunc_f64_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncUFloat64ToInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[15]) { |
| case '3': { |
| switch (buf[18]) { |
| case 's': |
| if (op == "i64.trunc_sat_f32_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSFloat32ToInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.trunc_sat_f32_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUFloat32ToInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[18]) { |
| case 's': |
| if (op == "i64.trunc_sat_f64_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatSFloat64ToInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64.trunc_sat_f64_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::TruncSatUFloat64ToInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'x': |
| if (op == "i64.xor"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::XorInt64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': { |
| switch (buf[6]) { |
| case 'a': { |
| switch (buf[7]) { |
| case 'b': |
| if (op == "i64x2.abs"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': |
| if (op == "i64x2.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'l': |
| if (op == "i64x2.all_true"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AllTrueVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'b': |
| if (op == "i64x2.bitmask"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::BitmaskVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': { |
| switch (buf[7]) { |
| case 'q': |
| if (op == "i64x2.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[9]) { |
| case 'e': { |
| switch (buf[13]) { |
| case 'h': { |
| switch (buf[24]) { |
| case 's': |
| if (op == "i64x2.extend_high_i32x4_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighSVecI32x4ToVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64x2.extend_high_i32x4_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendHighUVecI32x4ToVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[23]) { |
| case 's': |
| if (op == "i64x2.extend_low_i32x4_s"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowSVecI32x4ToVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64x2.extend_low_i32x4_u"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::ExtendLowUVecI32x4ToVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[13]) { |
| case 'h': { |
| switch (buf[24]) { |
| case 's': |
| if (op == "i64x2.extmul_high_i32x4_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighSVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64x2.extmul_high_i32x4_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulHighUVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[23]) { |
| case 's': |
| if (op == "i64x2.extmul_low_i32x4_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowSVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64x2.extmul_low_i32x4_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::ExtMulLowUVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'r': |
| if (op == "i64x2.extract_lane"sv) { |
| CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneVecI64x2, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'g': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "i64x2.ge_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "i64x2.gt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[7]) { |
| case 'a': |
| if (op == "i64x2.laneselect"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::LaneselectI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': |
| if (op == "i64x2.le_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "i64x2.lt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'm': |
| if (op == "i64x2.mul"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MulVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "i64x2.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "i64x2.neg"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'r': |
| if (op == "i64x2.replace_lane"sv) { |
| CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecI64x2, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': { |
| switch (buf[7]) { |
| case 'h': { |
| switch (buf[8]) { |
| case 'l': |
| if (op == "i64x2.shl"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShlVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i64x2.shr_s"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrSVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64x2.shr_u"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrUVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "i64x2.splat"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i64x2.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecI64x2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '8': { |
| switch (buf[6]) { |
| case 'a': { |
| switch (buf[7]) { |
| case 'b': |
| if (op == "i8x16.abs"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AbsVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'd': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "i8x16.add"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "i8x16.add_sat_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddSatSVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.add_sat_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AddSatUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'l': |
| if (op == "i8x16.all_true"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AllTrueVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'v': |
| if (op == "i8x16.avgr_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AvgrUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'b': |
| if (op == "i8x16.bitmask"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::BitmaskVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': { |
| switch (buf[7]) { |
| case 'q': |
| if (op == "i8x16.eq"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::EqVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'x': { |
| switch (buf[19]) { |
| case 's': |
| if (op == "i8x16.extract_lane_s"sv) { |
| CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneSVecI8x16, 16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.extract_lane_u"sv) { |
| CHECK_ERR(makeSIMDExtract(ctx, pos, annotations, SIMDExtractOp::ExtractLaneUVecI8x16, 16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'g': { |
| switch (buf[7]) { |
| case 'e': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i8x16.ge_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeSVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.ge_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GeUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i8x16.gt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtSVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.gt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::GtUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[7]) { |
| case 'a': |
| if (op == "i8x16.laneselect"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::LaneselectI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i8x16.le_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeSVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.le_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LeUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[9]) { |
| case 's': |
| if (op == "i8x16.lt_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtSVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.lt_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::LtUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[7]) { |
| case 'a': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i8x16.max_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxSVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.max_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MaxUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'i': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i8x16.min_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinSVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.min_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::MinUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[7]) { |
| case 'a': { |
| switch (buf[19]) { |
| case 's': |
| if (op == "i8x16.narrow_i16x8_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NarrowSVecI16x8ToVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.narrow_i16x8_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NarrowUVecI16x8ToVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "i8x16.ne"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::NeVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "i8x16.neg"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NegVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "i8x16.popcnt"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::PopcntVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[8]) { |
| case 'l': |
| if (op == "i8x16.relaxed_swizzle"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::RelaxedSwizzleVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'p': |
| if (op == "i8x16.replace_lane"sv) { |
| CHECK_ERR(makeSIMDReplace(ctx, pos, annotations, SIMDReplaceOp::ReplaceLaneVecI8x16, 16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[7]) { |
| case 'h': { |
| switch (buf[8]) { |
| case 'l': |
| if (op == "i8x16.shl"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShlVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[10]) { |
| case 's': |
| if (op == "i8x16.shr_s"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrSVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.shr_u"sv) { |
| CHECK_ERR(makeSIMDShift(ctx, pos, annotations, SIMDShiftOp::ShrUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'u': |
| if (op == "i8x16.shuffle"sv) { |
| CHECK_ERR(makeSIMDShuffle(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'p': |
| if (op == "i8x16.splat"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::SplatVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "i8x16.sub"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "i8x16.sub_sat_s"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubSatSVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "i8x16.sub_sat_u"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SubSatUVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'w': |
| if (op == "i8x16.swizzle"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::SwizzleVecI8x16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'l': { |
| switch (buf[6]) { |
| case 'g': |
| if (op == "local.get"sv) { |
| CHECK_ERR(makeLocalGet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "local.set"sv) { |
| CHECK_ERR(makeLocalSet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "local.tee"sv) { |
| CHECK_ERR(makeLocalTee(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'm': { |
| switch (buf[7]) { |
| case 'a': { |
| switch (buf[14]) { |
| case 'n': |
| if (op == "memory.atomic.notify"sv) { |
| CHECK_ERR(makeAtomicNotify(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'w': { |
| switch (buf[18]) { |
| case '3': |
| if (op == "memory.atomic.wait32"sv) { |
| CHECK_ERR(makeAtomicWait(ctx, pos, annotations, Type::i32)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '6': |
| if (op == "memory.atomic.wait64"sv) { |
| CHECK_ERR(makeAtomicWait(ctx, pos, annotations, Type::i64)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'c': |
| if (op == "memory.copy"sv) { |
| CHECK_ERR(makeMemoryCopy(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'f': |
| if (op == "memory.fill"sv) { |
| CHECK_ERR(makeMemoryFill(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': |
| if (op == "memory.grow"sv) { |
| CHECK_ERR(makeMemoryGrow(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "memory.init"sv) { |
| CHECK_ERR(makeMemoryInit(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "memory.size"sv) { |
| CHECK_ERR(makeMemorySize(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': |
| if (op == "nop"sv) { |
| CHECK_ERR(makeNop(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'p': |
| if (op == "pop"sv) { |
| CHECK_ERR(makePop(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': { |
| switch (buf[2]) { |
| case 'f': { |
| switch (buf[4]) { |
| case 'a': |
| if (op == "ref.as_non_null"sv) { |
| CHECK_ERR(makeRefAs(ctx, pos, annotations, RefAsNonNull)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'c': |
| if (op == "ref.cast"sv) { |
| CHECK_ERR(makeRefCast(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': |
| if (op == "ref.eq"sv) { |
| CHECK_ERR(makeRefEq(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'f': |
| if (op == "ref.func"sv) { |
| CHECK_ERR(makeRefFunc(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': { |
| switch (buf[5]) { |
| case '3': { |
| switch (buf[7]) { |
| case '\0': |
| if (op == "ref.i31"sv) { |
| CHECK_ERR(makeRefI31(ctx, pos, annotations, Unshared)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': |
| if (op == "ref.i31_shared"sv) { |
| CHECK_ERR(makeRefI31(ctx, pos, annotations, Shared)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 's': |
| if (op == "ref.is_null"sv) { |
| CHECK_ERR(makeRefIsNull(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': |
| if (op == "ref.null"sv) { |
| CHECK_ERR(makeRefNull(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': |
| if (op == "ref.test"sv) { |
| CHECK_ERR(makeRefTest(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 's': |
| if (op == "resume"sv) { |
| CHECK_ERR(makeResume(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': { |
| switch (buf[3]) { |
| case 'h': |
| if (op == "rethrow"sv) { |
| CHECK_ERR(makeRethrow(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': { |
| switch (buf[6]) { |
| case '\0': |
| if (op == "return"sv) { |
| CHECK_ERR(makeReturn(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[11]) { |
| case '\0': |
| if (op == "return_call"sv) { |
| CHECK_ERR(makeCall(ctx, pos, annotations, /*isReturn=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[12]) { |
| case 'i': |
| if (op == "return_call_indirect"sv) { |
| CHECK_ERR(makeCallIndirect(ctx, pos, annotations, /*isReturn=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': |
| if (op == "return_call_ref"sv) { |
| CHECK_ERR(makeCallRef(ctx, pos, annotations, /*isReturn=*/true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 's': { |
| switch (buf[1]) { |
| case 'e': |
| if (op == "select"sv) { |
| CHECK_ERR(makeSelect(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 't': { |
| switch (buf[3]) { |
| case 'i': { |
| switch (buf[6]) { |
| case '.': { |
| switch (buf[7]) { |
| case 'a': |
| if (op == "string.as_wtf16"sv) { |
| CHECK_ERR(ignore(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'c': { |
| switch (buf[9]) { |
| case 'm': |
| if (op == "string.compare"sv) { |
| CHECK_ERR(makeStringEq(ctx, pos, annotations, StringEqCompare)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': { |
| switch (buf[10]) { |
| case 'c': |
| if (op == "string.concat"sv) { |
| CHECK_ERR(makeStringConcat(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "string.const"sv) { |
| CHECK_ERR(makeStringConst(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'e': { |
| switch (buf[8]) { |
| case 'n': { |
| switch (buf[14]) { |
| case 'l': |
| if (op == "string.encode_lossy_utf8_array"sv) { |
| CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeLossyUTF8Array)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'w': |
| if (op == "string.encode_wtf16_array"sv) { |
| CHECK_ERR(makeStringEncode(ctx, pos, annotations, StringEncodeWTF16Array)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'q': |
| if (op == "string.eq"sv) { |
| CHECK_ERR(makeStringEq(ctx, pos, annotations, StringEqEqual)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'f': |
| if (op == "string.from_code_point"sv) { |
| CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewFromCodePoint)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'm': { |
| switch (buf[15]) { |
| case 'u': |
| if (op == "string.measure_utf8"sv) { |
| CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureUTF8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'w': |
| if (op == "string.measure_wtf16"sv) { |
| CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureWTF16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[11]) { |
| case 'l': |
| if (op == "string.new_lossy_utf8_array"sv) { |
| CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewLossyUTF8Array)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'w': |
| if (op == "string.new_wtf16_array"sv) { |
| CHECK_ERR(makeStringNew(ctx, pos, annotations, StringNewWTF16Array)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'v': { |
| switch (buf[17]) { |
| case 'g': |
| if (op == "stringview_wtf16.get_codeunit"sv) { |
| CHECK_ERR(makeStringWTF16Get(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'l': |
| if (op == "stringview_wtf16.length"sv) { |
| CHECK_ERR(makeStringMeasure(ctx, pos, annotations, StringMeasureWTF16)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "stringview_wtf16.slice"sv) { |
| CHECK_ERR(makeStringSliceWTF(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'u': { |
| switch (buf[7]) { |
| case 'a': { |
| switch (buf[14]) { |
| case 'g': { |
| switch (buf[17]) { |
| case '\0': |
| if (op == "struct.atomic.get"sv) { |
| CHECK_ERR(makeAtomicStructGet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[18]) { |
| case 's': |
| if (op == "struct.atomic.get_s"sv) { |
| CHECK_ERR(makeAtomicStructGet(ctx, pos, annotations, true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "struct.atomic.get_u"sv) { |
| CHECK_ERR(makeAtomicStructGet(ctx, pos, annotations, false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 's': |
| if (op == "struct.atomic.set"sv) { |
| CHECK_ERR(makeAtomicStructSet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'g': { |
| switch (buf[10]) { |
| case '\0': |
| if (op == "struct.get"sv) { |
| CHECK_ERR(makeStructGet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': { |
| switch (buf[11]) { |
| case 's': |
| if (op == "struct.get_s"sv) { |
| CHECK_ERR(makeStructGet(ctx, pos, annotations, true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "struct.get_u"sv) { |
| CHECK_ERR(makeStructGet(ctx, pos, annotations, false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'n': { |
| switch (buf[10]) { |
| case '\0': |
| if (op == "struct.new"sv) { |
| CHECK_ERR(makeStructNew(ctx, pos, annotations, false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': |
| if (op == "struct.new_default"sv) { |
| CHECK_ERR(makeStructNew(ctx, pos, annotations, true)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 's': |
| if (op == "struct.set"sv) { |
| CHECK_ERR(makeStructSet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'u': |
| if (op == "suspend"sv) { |
| CHECK_ERR(makeSuspend(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 't': { |
| switch (buf[1]) { |
| case 'a': { |
| switch (buf[6]) { |
| case 'c': |
| if (op == "table.copy"sv) { |
| CHECK_ERR(makeTableCopy(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'f': |
| if (op == "table.fill"sv) { |
| CHECK_ERR(makeTableFill(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'g': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "table.get"sv) { |
| CHECK_ERR(makeTableGet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'r': |
| if (op == "table.grow"sv) { |
| CHECK_ERR(makeTableGrow(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'i': |
| if (op == "table.init"sv) { |
| CHECK_ERR(makeTableInit(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': { |
| switch (buf[7]) { |
| case 'e': |
| if (op == "table.set"sv) { |
| CHECK_ERR(makeTableSet(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'i': |
| if (op == "table.size"sv) { |
| CHECK_ERR(makeTableSize(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'h': { |
| switch (buf[5]) { |
| case '\0': |
| if (op == "throw"sv) { |
| CHECK_ERR(makeThrow(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '_': |
| if (op == "throw_ref"sv) { |
| CHECK_ERR(makeThrowRef(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'u': { |
| switch (buf[6]) { |
| case 'd': |
| if (op == "tuple.drop"sv) { |
| CHECK_ERR(makeTupleDrop(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'e': |
| if (op == "tuple.extract"sv) { |
| CHECK_ERR(makeTupleExtract(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'm': |
| if (op == "tuple.make"sv) { |
| CHECK_ERR(makeTupleMake(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'u': |
| if (op == "unreachable"sv) { |
| CHECK_ERR(makeUnreachable(ctx, pos, annotations)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'v': { |
| switch (buf[5]) { |
| case 'a': { |
| switch (buf[7]) { |
| case 'd': { |
| switch (buf[8]) { |
| case '\0': |
| if (op == "v128.and"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AndVec128)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'n': |
| if (op == "v128.andnot"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::AndNotVec128)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'y': |
| if (op == "v128.any_true"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::AnyTrueVec128)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'b': |
| if (op == "v128.bitselect"sv) { |
| CHECK_ERR(makeSIMDTernary(ctx, pos, annotations, SIMDTernaryOp::Bitselect)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'c': |
| if (op == "v128.const"sv) { |
| CHECK_ERR(makeConst(ctx, pos, annotations, Type::v128)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'l': { |
| switch (buf[9]) { |
| case '\0': |
| if (op == "v128.load"sv) { |
| CHECK_ERR(makeLoad(ctx, pos, annotations, Type::v128, /*signed=*/false, 16, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': { |
| switch (buf[11]) { |
| case '_': { |
| switch (buf[12]) { |
| case 'l': |
| if (op == "v128.load16_lane"sv) { |
| CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Load16LaneVec128, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "v128.load16_splat"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load16SplatVec128, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "v128.load16x4_s"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load16x4SVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "v128.load16x4_u"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load16x4UVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '3': { |
| switch (buf[11]) { |
| case '_': { |
| switch (buf[12]) { |
| case 'l': |
| if (op == "v128.load32_lane"sv) { |
| CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Load32LaneVec128, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "v128.load32_splat"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load32SplatVec128, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'z': |
| if (op == "v128.load32_zero"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load32ZeroVec128, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': { |
| switch (buf[14]) { |
| case 's': |
| if (op == "v128.load32x2_s"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load32x2SVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "v128.load32x2_u"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load32x2UVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case '6': { |
| switch (buf[12]) { |
| case 'l': |
| if (op == "v128.load64_lane"sv) { |
| CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Load64LaneVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "v128.load64_splat"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load64SplatVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'z': |
| if (op == "v128.load64_zero"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load64ZeroVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case '8': { |
| switch (buf[10]) { |
| case '_': { |
| switch (buf[11]) { |
| case 'l': |
| if (op == "v128.load8_lane"sv) { |
| CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Load8LaneVec128, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': |
| if (op == "v128.load8_splat"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load8SplatVec128, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': { |
| switch (buf[13]) { |
| case 's': |
| if (op == "v128.load8x8_s"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load8x8SVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'u': |
| if (op == "v128.load8x8_u"sv) { |
| CHECK_ERR(makeSIMDLoad(ctx, pos, annotations, SIMDLoadOp::Load8x8UVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| } |
| case 'n': |
| if (op == "v128.not"sv) { |
| CHECK_ERR(makeUnary(ctx, pos, annotations, UnaryOp::NotVec128)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 'o': |
| if (op == "v128.or"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::OrVec128)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case 's': { |
| switch (buf[10]) { |
| case '\0': |
| if (op == "v128.store"sv) { |
| CHECK_ERR(makeStore(ctx, pos, annotations, Type::v128, 16, /*isAtomic=*/false)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '1': |
| if (op == "v128.store16_lane"sv) { |
| CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Store16LaneVec128, 2)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '3': |
| if (op == "v128.store32_lane"sv) { |
| CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Store32LaneVec128, 4)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '6': |
| if (op == "v128.store64_lane"sv) { |
| CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Store64LaneVec128, 8)); |
| return Ok{}; |
| } |
| goto parse_error; |
| case '8': |
| if (op == "v128.store8_lane"sv) { |
| CHECK_ERR(makeSIMDLoadStoreLane(ctx, pos, annotations, SIMDLoadStoreLaneOp::Store8LaneVec128, 1)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| case 'x': |
| if (op == "v128.xor"sv) { |
| CHECK_ERR(makeBinary(ctx, pos, annotations, BinaryOp::XorVec128)); |
| return Ok{}; |
| } |
| goto parse_error; |
| default: goto parse_error; |
| } |
| } |
| default: goto parse_error; |
| } |
| parse_error: |
| return ctx.in.err(pos, "unrecognized instruction"); |
| |
| // NOLINTEND |
| |
| // clang-format on |
