diff options
Diffstat (limited to 'third_party/wasm2c/src/prebuilt')
6 files changed, 3241 insertions, 0 deletions
diff --git a/third_party/wasm2c/src/prebuilt/.clang-format b/third_party/wasm2c/src/prebuilt/.clang-format new file mode 100644 index 0000000000..9d159247d5 --- /dev/null +++ b/third_party/wasm2c/src/prebuilt/.clang-format @@ -0,0 +1,2 @@ +DisableFormat: true +SortIncludes: false diff --git a/third_party/wasm2c/src/prebuilt/lexer-keywords.cc b/third_party/wasm2c/src/prebuilt/lexer-keywords.cc new file mode 100644 index 0000000000..4a7da0e06d --- /dev/null +++ b/third_party/wasm2c/src/prebuilt/lexer-keywords.cc @@ -0,0 +1,1796 @@ +/* C++ code produced by gperf version 3.1 */ +/* Command-line: gperf -m 50 -L C++ -N InWordSet -E -t -c --output-file=src/prebuilt/lexer-keywords.cc src/lexer-keywords.txt */ +/* Computed positions: -k'1,3,5-8,10,12,15,17-19,23,27,$' */ + +#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \ + && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \ + && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \ + && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \ + && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \ + && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \ + && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \ + && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \ + && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \ + && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \ + && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \ + && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \ + && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \ + && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \ + && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \ + && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \ + && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \ + && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \ + && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \ + && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \ + && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \ + && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \ + && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)) +/* The character set is not based on ISO-646. */ +#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gperf@gnu.org>." +#endif + +#line 1 "src/lexer-keywords.txt" +struct TokenInfo { + TokenInfo(const char* name) : name(name) {} + TokenInfo(const char* name, TokenType token_type) + : name(name), token_type(token_type) {} + TokenInfo(const char* name, Type value_type) + : name(name), token_type(TokenType::ValueType), value_type(value_type) {} + TokenInfo(const char* name, Type value_type, TokenType token_type) + : name(name), token_type(token_type), value_type(value_type) {} + TokenInfo(const char* name, TokenType token_type, Opcode opcode) + : name(name), token_type(token_type), opcode(opcode) {} + + const char* name; + TokenType token_type; + union { + Type value_type; + Opcode opcode; + }; +}; +/* maximum key range = 2423, duplicates = 0 */ + +class Perfect_Hash +{ +private: + static inline unsigned int hash (const char *str, size_t len); +public: + static struct TokenInfo *InWordSet (const char *str, size_t len); +}; + +inline unsigned int +Perfect_Hash::hash (const char *str, size_t len) +{ + static unsigned short asso_values[] = + { + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 7, 2453, 2453, 532, + 325, 8, 13, 7, 327, 314, 111, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 220, 10, 35, 678, 60, + 49, 11, 538, 7, 399, 128, 15, 34, 9, 56, + 13, 64, 766, 737, 14, 9, 19, 7, 411, 435, + 122, 393, 105, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, 2453, + 2453, 2453, 2453, 2453, 2453, 2453, 2453 + }; + unsigned int hval = len; + + switch (hval) + { + default: + hval += asso_values[static_cast<unsigned char>(str[26])]; + [[fallthrough]]; + case 26: + case 25: + case 24: + case 23: + hval += asso_values[static_cast<unsigned char>(str[22])]; + [[fallthrough]]; + case 22: + case 21: + case 20: + case 19: + hval += asso_values[static_cast<unsigned char>(str[18])]; + [[fallthrough]]; + case 18: + hval += asso_values[static_cast<unsigned char>(str[17])]; + [[fallthrough]]; + case 17: + hval += asso_values[static_cast<unsigned char>(str[16])]; + [[fallthrough]]; + case 16: + case 15: + hval += asso_values[static_cast<unsigned char>(str[14])]; + [[fallthrough]]; + case 14: + case 13: + case 12: + hval += asso_values[static_cast<unsigned char>(str[11])]; + [[fallthrough]]; + case 11: + case 10: + hval += asso_values[static_cast<unsigned char>(str[9])]; + [[fallthrough]]; + case 9: + case 8: + hval += asso_values[static_cast<unsigned char>(str[7])]; + [[fallthrough]]; + case 7: + hval += asso_values[static_cast<unsigned char>(str[6])]; + [[fallthrough]]; + case 6: + hval += asso_values[static_cast<unsigned char>(str[5])]; + [[fallthrough]]; + case 5: + hval += asso_values[static_cast<unsigned char>(str[4])]; + [[fallthrough]]; + case 4: + case 3: + hval += asso_values[static_cast<unsigned char>(str[2]+1)]; + [[fallthrough]]; + case 2: + case 1: + hval += asso_values[static_cast<unsigned char>(str[0]+1)]; + break; + } + return hval + asso_values[static_cast<unsigned char>(str[len - 1])]; +} + +struct TokenInfo * +Perfect_Hash::InWordSet (const char *str, size_t len) +{ + enum + { + TOTAL_KEYWORDS = 590, + MIN_WORD_LENGTH = 2, + MAX_WORD_LENGTH = 32, + MIN_HASH_VALUE = 30, + MAX_HASH_VALUE = 2452 + }; + + static struct TokenInfo wordlist[] = + { + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, +#line 145 "src/lexer-keywords.txt" + {"f64", Type::F64}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 456 "src/lexer-keywords.txt" + {"i64", Type::I64}, + {""}, {""}, {""}, +#line 547 "src/lexer-keywords.txt" + {"mut", TokenType::Mut}, + {""}, {""}, {""}, +#line 115 "src/lexer-keywords.txt" + {"f32x4", TokenType::F32X4}, + {""}, {""}, +#line 128 "src/lexer-keywords.txt" + {"f64.ge", TokenType::Compare, Opcode::F64Ge}, +#line 67 "src/lexer-keywords.txt" + {"f32.ge", TokenType::Compare, Opcode::F32Ge}, +#line 130 "src/lexer-keywords.txt" + {"f64.le", TokenType::Compare, Opcode::F64Le}, +#line 69 "src/lexer-keywords.txt" + {"f32.le", TokenType::Compare, Opcode::F32Le}, + {""}, +#line 356 "src/lexer-keywords.txt" + {"i32x4", TokenType::I32X4}, +#line 138 "src/lexer-keywords.txt" + {"f64.ne", TokenType::Compare, Opcode::F64Ne}, +#line 77 "src/lexer-keywords.txt" + {"f32.ne", TokenType::Compare, Opcode::F32Ne}, +#line 40 "src/lexer-keywords.txt" + {"data", TokenType::Data}, + {""}, +#line 137 "src/lexer-keywords.txt" + {"f64.neg", TokenType::Unary, Opcode::F64Neg}, +#line 76 "src/lexer-keywords.txt" + {"f32.neg", TokenType::Unary, Opcode::F32Neg}, +#line 546 "src/lexer-keywords.txt" + {"module", TokenType::Module}, +#line 565 "src/lexer-keywords.txt" + {"return", TokenType::Return, Opcode::Return}, +#line 432 "src/lexer-keywords.txt" + {"i64.ne", TokenType::Compare, Opcode::I64Ne}, +#line 289 "src/lexer-keywords.txt" + {"i32.ne", TokenType::Compare, Opcode::I32Ne}, +#line 129 "src/lexer-keywords.txt" + {"f64.gt", TokenType::Compare, Opcode::F64Gt}, +#line 68 "src/lexer-keywords.txt" + {"f32.gt", TokenType::Compare, Opcode::F32Gt}, +#line 132 "src/lexer-keywords.txt" + {"f64.lt", TokenType::Compare, Opcode::F64Lt}, +#line 71 "src/lexer-keywords.txt" + {"f32.lt", TokenType::Compare, Opcode::F32Lt}, + {""}, {""}, +#line 559 "src/lexer-keywords.txt" + {"ref.null", TokenType::RefNull, Opcode::RefNull}, +#line 93 "src/lexer-keywords.txt" + {"f32x4.ge", TokenType::Compare, Opcode::F32X4Ge}, + {""}, +#line 95 "src/lexer-keywords.txt" + {"f32x4.le", TokenType::Compare, Opcode::F32X4Le}, +#line 101 "src/lexer-keywords.txt" + {"f32x4.neg", TokenType::Unary, Opcode::F32X4Neg}, +#line 33 "src/lexer-keywords.txt" + {"br", TokenType::Br, Opcode::Br}, +#line 43 "src/lexer-keywords.txt" + {"do", TokenType::Do}, +#line 102 "src/lexer-keywords.txt" + {"f32x4.ne", TokenType::Compare, Opcode::F32X4Ne}, + {""}, {""}, +#line 561 "src/lexer-keywords.txt" + {"result", TokenType::Result}, + {""}, +#line 341 "src/lexer-keywords.txt" + {"i32x4.neg", TokenType::Unary, Opcode::I32X4Neg}, + {""}, +#line 322 "src/lexer-keywords.txt" + {"i32x4.ge_u", TokenType::Compare, Opcode::I32X4GeU}, +#line 342 "src/lexer-keywords.txt" + {"i32x4.ne", TokenType::Compare, Opcode::I32X4Ne}, +#line 326 "src/lexer-keywords.txt" + {"i32x4.le_u", TokenType::Compare, Opcode::I32X4LeU}, +#line 94 "src/lexer-keywords.txt" + {"f32x4.gt", TokenType::Compare, Opcode::F32X4Gt}, +#line 321 "src/lexer-keywords.txt" + {"i32x4.ge_s", TokenType::Compare, Opcode::I32X4GeS}, +#line 96 "src/lexer-keywords.txt" + {"f32x4.lt", TokenType::Compare, Opcode::F32X4Lt}, +#line 325 "src/lexer-keywords.txt" + {"i32x4.le_s", TokenType::Compare, Opcode::I32X4LeS}, + {""}, +#line 324 "src/lexer-keywords.txt" + {"i32x4.gt_u", TokenType::Compare, Opcode::I32X4GtU}, +#line 577 "src/lexer-keywords.txt" + {"table", TokenType::Table}, +#line 334 "src/lexer-keywords.txt" + {"i32x4.lt_u", TokenType::Compare, Opcode::I32X4LtU}, + {""}, +#line 323 "src/lexer-keywords.txt" + {"i32x4.gt_s", TokenType::Compare, Opcode::I32X4GtS}, + {""}, +#line 333 "src/lexer-keywords.txt" + {"i32x4.lt_s", TokenType::Compare, Opcode::I32X4LtS}, + {""}, {""}, +#line 135 "src/lexer-keywords.txt" + {"f64.mul", TokenType::Binary, Opcode::F64Mul}, +#line 74 "src/lexer-keywords.txt" + {"f32.mul", TokenType::Binary, Opcode::F32Mul}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 431 "src/lexer-keywords.txt" + {"i64.mul", TokenType::Binary, Opcode::I64Mul}, +#line 288 "src/lexer-keywords.txt" + {"i32.mul", TokenType::Binary, Opcode::I32Mul}, + {""}, {""}, +#line 100 "src/lexer-keywords.txt" + {"f32x4.nearest", TokenType::Unary, Opcode::F32X4Nearest}, + {""}, +#line 99 "src/lexer-keywords.txt" + {"f32x4.mul", TokenType::Binary, Opcode::F32X4Mul}, + {""}, +#line 36 "src/lexer-keywords.txt" + {"call", TokenType::Call, Opcode::Call}, + {""}, +#line 433 "src/lexer-keywords.txt" + {"i64.or", TokenType::Binary, Opcode::I64Or}, +#line 290 "src/lexer-keywords.txt" + {"i32.or", TokenType::Binary, Opcode::I32Or}, + {""}, {""}, +#line 340 "src/lexer-keywords.txt" + {"i32x4.mul", TokenType::Binary, Opcode::I32X4Mul}, + {""}, +#line 136 "src/lexer-keywords.txt" + {"f64.nearest", TokenType::Unary, Opcode::F64Nearest}, +#line 75 "src/lexer-keywords.txt" + {"f32.nearest", TokenType::Unary, Opcode::F32Nearest}, +#line 535 "src/lexer-keywords.txt" + {"local", TokenType::Local}, + {""}, {""}, +#line 572 "src/lexer-keywords.txt" + {"table.get", TokenType::TableGet, Opcode::TableGet}, +#line 569 "src/lexer-keywords.txt" + {"struct", Type::Struct, TokenType::Struct}, +#line 575 "src/lexer-keywords.txt" + {"table.set", TokenType::TableSet, Opcode::TableSet}, +#line 86 "src/lexer-keywords.txt" + {"f32x4.ceil", TokenType::Unary, Opcode::F32X4Ceil}, +#line 180 "src/lexer-keywords.txt" + {"func", Type::FuncRef, TokenType::Func}, +#line 144 "src/lexer-keywords.txt" + {"f64.trunc", TokenType::Unary, Opcode::F64Trunc}, +#line 82 "src/lexer-keywords.txt" + {"f32.trunc", TokenType::Unary, Opcode::F32Trunc}, +#line 41 "src/lexer-keywords.txt" + {"declare", TokenType::Declare}, + {""}, +#line 142 "src/lexer-keywords.txt" + {"f64.store", TokenType::Store, Opcode::F64Store}, +#line 80 "src/lexer-keywords.txt" + {"f32.store", TokenType::Store, Opcode::F32Store}, + {""}, {""}, {""}, +#line 438 "src/lexer-keywords.txt" + {"i64.rotl", TokenType::Binary, Opcode::I64Rotl}, +#line 295 "src/lexer-keywords.txt" + {"i32.rotl", TokenType::Binary, Opcode::I32Rotl}, + {""}, +#line 446 "src/lexer-keywords.txt" + {"i64.store", TokenType::Store, Opcode::I64Store}, +#line 302 "src/lexer-keywords.txt" + {"i32.store", TokenType::Store, Opcode::I32Store}, + {""}, {""}, +#line 113 "src/lexer-keywords.txt" + {"f32x4.trunc", TokenType::Unary, Opcode::F32X4Trunc}, + {""}, {""}, +#line 439 "src/lexer-keywords.txt" + {"i64.rotr", TokenType::Binary, Opcode::I64Rotr}, +#line 296 "src/lexer-keywords.txt" + {"i32.rotr", TokenType::Binary, Opcode::I32Rotr}, + {""}, +#line 42 "src/lexer-keywords.txt" + {"delegate", TokenType::Delegate}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 532 "src/lexer-keywords.txt" + {"local.get", TokenType::LocalGet, Opcode::LocalGet}, + {""}, +#line 533 "src/lexer-keywords.txt" + {"local.set", TokenType::LocalSet, Opcode::LocalSet}, + {""}, +#line 534 "src/lexer-keywords.txt" + {"local.tee", TokenType::LocalTee, Opcode::LocalTee}, + {""}, {""}, {""}, +#line 367 "src/lexer-keywords.txt" + {"i64.and", TokenType::Binary, Opcode::I64And}, +#line 238 "src/lexer-keywords.txt" + {"i32.and", TokenType::Binary, Opcode::I32And}, +#line 85 "src/lexer-keywords.txt" + {"f32x4.add", TokenType::Binary, Opcode::F32X4Add}, + {""}, +#line 566 "src/lexer-keywords.txt" + {"select", TokenType::Select, Opcode::Select}, + {""}, {""}, {""}, {""}, {""}, +#line 315 "src/lexer-keywords.txt" + {"i32x4.add", TokenType::Binary, Opcode::I32X4Add}, + {""}, {""}, +#line 119 "src/lexer-keywords.txt" + {"f64.const", TokenType::Const, Opcode::F64Const}, +#line 57 "src/lexer-keywords.txt" + {"f32.const", TokenType::Const, Opcode::F32Const}, + {""}, +#line 109 "src/lexer-keywords.txt" + {"f32x4.replace_lane", TokenType::SimdLaneOp, Opcode::F32X4ReplaceLane}, + {""}, {""}, {""}, {""}, +#line 405 "src/lexer-keywords.txt" + {"i64.const", TokenType::Const, Opcode::I64Const}, +#line 267 "src/lexer-keywords.txt" + {"i32.const", TokenType::Const, Opcode::I32Const}, + {""}, +#line 344 "src/lexer-keywords.txt" + {"i32x4.replace_lane", TokenType::SimdLaneOp, Opcode::I32X4ReplaceLane}, + {""}, {""}, {""}, +#line 117 "src/lexer-keywords.txt" + {"f64.add", TokenType::Binary, Opcode::F64Add}, +#line 55 "src/lexer-keywords.txt" + {"f32.add", TokenType::Binary, Opcode::F32Add}, +#line 107 "src/lexer-keywords.txt" + {"f32x4.relaxed_min", TokenType::Binary, Opcode::F32X4RelaxedMin}, + {""}, {""}, {""}, {""}, {""}, +#line 366 "src/lexer-keywords.txt" + {"i64.add", TokenType::Binary, Opcode::I64Add}, +#line 237 "src/lexer-keywords.txt" + {"i32.add", TokenType::Binary, Opcode::I32Add}, + {""}, {""}, +#line 556 "src/lexer-keywords.txt" + {"ref.extern", TokenType::RefExtern}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, +#line 131 "src/lexer-keywords.txt" + {"f64.load", TokenType::Load, Opcode::F64Load}, +#line 70 "src/lexer-keywords.txt" + {"f32.load", TokenType::Load, Opcode::F32Load}, + {""}, +#line 134 "src/lexer-keywords.txt" + {"f64.min", TokenType::Binary, Opcode::F64Min}, +#line 73 "src/lexer-keywords.txt" + {"f32.min", TokenType::Binary, Opcode::F32Min}, + {""}, {""}, {""}, +#line 428 "src/lexer-keywords.txt" + {"i64.load", TokenType::Load, Opcode::I64Load}, +#line 285 "src/lexer-keywords.txt" + {"i32.load", TokenType::Load, Opcode::I32Load}, + {""}, +#line 118 "src/lexer-keywords.txt" + {"f64.ceil", TokenType::Unary, Opcode::F64Ceil}, +#line 56 "src/lexer-keywords.txt" + {"f32.ceil", TokenType::Unary, Opcode::F32Ceil}, +#line 98 "src/lexer-keywords.txt" + {"f32x4.min", TokenType::Binary, Opcode::F32X4Min}, + {""}, +#line 488 "src/lexer-keywords.txt" + {"i64.xor", TokenType::Binary, Opcode::I64Xor}, +#line 365 "src/lexer-keywords.txt" + {"i32.xor", TokenType::Binary, Opcode::I32Xor}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 576 "src/lexer-keywords.txt" + {"table.size", TokenType::TableSize, Opcode::TableSize}, + {""}, {""}, +#line 97 "src/lexer-keywords.txt" + {"f32x4.max", TokenType::Binary, Opcode::F32X4Max}, + {""}, +#line 343 "src/lexer-keywords.txt" + {"i32x4.relaxed_laneselect", TokenType::Ternary, Opcode::I32X4RelaxedLaneSelect}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, +#line 574 "src/lexer-keywords.txt" + {"table.init", TokenType::TableInit, Opcode::TableInit}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 417 "src/lexer-keywords.txt" + {"i64.ge_u", TokenType::Compare, Opcode::I64GeU}, +#line 276 "src/lexer-keywords.txt" + {"i32.ge_u", TokenType::Compare, Opcode::I32GeU}, +#line 421 "src/lexer-keywords.txt" + {"i64.le_u", TokenType::Compare, Opcode::I64LeU}, +#line 280 "src/lexer-keywords.txt" + {"i32.le_u", TokenType::Compare, Opcode::I32LeU}, +#line 416 "src/lexer-keywords.txt" + {"i64.ge_s", TokenType::Compare, Opcode::I64GeS}, +#line 275 "src/lexer-keywords.txt" + {"i32.ge_s", TokenType::Compare, Opcode::I32GeS}, +#line 420 "src/lexer-keywords.txt" + {"i64.le_s", TokenType::Compare, Opcode::I64LeS}, +#line 279 "src/lexer-keywords.txt" + {"i32.le_s", TokenType::Compare, Opcode::I32LeS}, +#line 419 "src/lexer-keywords.txt" + {"i64.gt_u", TokenType::Compare, Opcode::I64GtU}, +#line 278 "src/lexer-keywords.txt" + {"i32.gt_u", TokenType::Compare, Opcode::I32GtU}, +#line 430 "src/lexer-keywords.txt" + {"i64.lt_u", TokenType::Compare, Opcode::I64LtU}, +#line 287 "src/lexer-keywords.txt" + {"i32.lt_u", TokenType::Compare, Opcode::I32LtU}, +#line 418 "src/lexer-keywords.txt" + {"i64.gt_s", TokenType::Compare, Opcode::I64GtS}, +#line 277 "src/lexer-keywords.txt" + {"i32.gt_s", TokenType::Compare, Opcode::I32GtS}, +#line 429 "src/lexer-keywords.txt" + {"i64.lt_s", TokenType::Compare, Opcode::I64LtS}, +#line 286 "src/lexer-keywords.txt" + {"i32.lt_s", TokenType::Compare, Opcode::I32LtS}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 91 "src/lexer-keywords.txt" + {"f32x4.extract_lane", TokenType::SimdLaneOp, Opcode::F32X4ExtractLane}, + {""}, +#line 403 "src/lexer-keywords.txt" + {"i64.atomic.store", TokenType::AtomicStore, Opcode::I64AtomicStore}, +#line 265 "src/lexer-keywords.txt" + {"i32.atomic.store", TokenType::AtomicStore, Opcode::I32AtomicStore}, +#line 404 "src/lexer-keywords.txt" + {"i64.clz", TokenType::Unary, Opcode::I64Clz}, +#line 266 "src/lexer-keywords.txt" + {"i32.clz", TokenType::Unary, Opcode::I32Clz}, + {""}, {""}, +#line 320 "src/lexer-keywords.txt" + {"i32x4.extract_lane", TokenType::SimdLaneOp, Opcode::I32X4ExtractLane}, + {""}, {""}, {""}, {""}, {""}, +#line 406 "src/lexer-keywords.txt" + {"i64.ctz", TokenType::Unary, Opcode::I64Ctz}, +#line 268 "src/lexer-keywords.txt" + {"i32.ctz", TokenType::Unary, Opcode::I32Ctz}, +#line 108 "src/lexer-keywords.txt" + {"f32x4.relaxed_nmadd", TokenType::Ternary, Opcode::F32X4RelaxedNmadd}, + {""}, +#line 396 "src/lexer-keywords.txt" + {"i64.atomic.rmw.or", TokenType::AtomicRmw, Opcode::I64AtomicRmwOr}, +#line 259 "src/lexer-keywords.txt" + {"i32.atomic.rmw.or", TokenType::AtomicRmw, Opcode::I32AtomicRmwOr}, + {""}, {""}, {""}, +#line 105 "src/lexer-keywords.txt" + {"f32x4.relaxed_madd", TokenType::Ternary, Opcode::F32X4RelaxedMadd}, + {""}, +#line 330 "src/lexer-keywords.txt" + {"i32x4.relaxed_trunc_f64x2_u_zero", TokenType::Unary, Opcode::I32X4RelaxedTruncF64X2UZero}, +#line 383 "src/lexer-keywords.txt" + {"i64.atomic.rmw32.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32SubU}, +#line 329 "src/lexer-keywords.txt" + {"i32x4.relaxed_trunc_f64x2_s_zero", TokenType::Unary, Opcode::I32X4RelaxedTruncF64X2SZero}, +#line 449 "src/lexer-keywords.txt" + {"i64.trunc_f32_u", TokenType::Convert, Opcode::I64TruncF32U}, +#line 305 "src/lexer-keywords.txt" + {"i32.trunc_f32_u", TokenType::Convert, Opcode::I32TruncF32U}, + {""}, {""}, +#line 448 "src/lexer-keywords.txt" + {"i64.trunc_f32_s", TokenType::Convert, Opcode::I64TruncF32S}, +#line 304 "src/lexer-keywords.txt" + {"i32.trunc_f32_s", TokenType::Convert, Opcode::I32TruncF32S}, + {""}, +#line 437 "src/lexer-keywords.txt" + {"i64.rem_u", TokenType::Binary, Opcode::I64RemU}, +#line 294 "src/lexer-keywords.txt" + {"i32.rem_u", TokenType::Binary, Opcode::I32RemU}, +#line 436 "src/lexer-keywords.txt" + {"i64.rem_s", TokenType::Binary, Opcode::I64RemS}, +#line 293 "src/lexer-keywords.txt" + {"i32.rem_s", TokenType::Binary, Opcode::I32RemS}, +#line 83 "src/lexer-keywords.txt" + {"f32", Type::F32}, + {""}, {""}, +#line 316 "src/lexer-keywords.txt" + {"i32x4.all_true", TokenType::Unary, Opcode::I32X4AllTrue}, + {""}, {""}, {""}, {""}, +#line 312 "src/lexer-keywords.txt" + {"i32", Type::I32}, +#line 564 "src/lexer-keywords.txt" + {"return_call", TokenType::ReturnCall, Opcode::ReturnCall}, + {""}, {""}, {""}, +#line 133 "src/lexer-keywords.txt" + {"f64.max", TokenType::Binary, Opcode::F64Max}, +#line 72 "src/lexer-keywords.txt" + {"f32.max", TokenType::Binary, Opcode::F32Max}, + {""}, {""}, +#line 445 "src/lexer-keywords.txt" + {"i64.store8", TokenType::Store, Opcode::I64Store8}, +#line 301 "src/lexer-keywords.txt" + {"i32.store8", TokenType::Store, Opcode::I32Store8}, +#line 380 "src/lexer-keywords.txt" + {"i64.atomic.rmw32.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AndU}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 336 "src/lexer-keywords.txt" + {"i32x4.max_u", TokenType::Binary, Opcode::I32X4MaxU}, + {""}, +#line 335 "src/lexer-keywords.txt" + {"i32x4.max_s", TokenType::Binary, Opcode::I32X4MaxS}, + {""}, {""}, {""}, +#line 371 "src/lexer-keywords.txt" + {"i64.atomic.load", TokenType::AtomicLoad, Opcode::I64AtomicLoad}, +#line 241 "src/lexer-keywords.txt" + {"i32.atomic.load", TokenType::AtomicLoad, Opcode::I32AtomicLoad}, + {""}, {""}, {""}, +#line 153 "src/lexer-keywords.txt" + {"f64x2.ge", TokenType::Compare, Opcode::F64X2Ge}, + {""}, +#line 155 "src/lexer-keywords.txt" + {"f64x2.le", TokenType::Compare, Opcode::F64X2Le}, +#line 161 "src/lexer-keywords.txt" + {"f64x2.neg", TokenType::Unary, Opcode::F64X2Neg}, +#line 399 "src/lexer-keywords.txt" + {"i64.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I64AtomicRmwXor}, +#line 262 "src/lexer-keywords.txt" + {"i32.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I32AtomicRmwXor}, +#line 162 "src/lexer-keywords.txt" + {"f64x2.ne", TokenType::Compare, Opcode::F64X2Ne}, + {""}, +#line 382 "src/lexer-keywords.txt" + {"i64.atomic.rmw32.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32OrU}, + {""}, {""}, +#line 469 "src/lexer-keywords.txt" + {"i64x2.neg", TokenType::Unary, Opcode::I64X2Neg}, + {""}, {""}, +#line 463 "src/lexer-keywords.txt" + {"i64x2.ne", TokenType::Binary, Opcode::I64X2Ne}, +#line 379 "src/lexer-keywords.txt" + {"i64.atomic.rmw32.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AddU}, +#line 154 "src/lexer-keywords.txt" + {"f64x2.gt", TokenType::Compare, Opcode::F64X2Gt}, +#line 467 "src/lexer-keywords.txt" + {"i64x2.ge_s", TokenType::Binary, Opcode::I64X2GeS}, +#line 156 "src/lexer-keywords.txt" + {"f64x2.lt", TokenType::Compare, Opcode::F64X2Lt}, +#line 466 "src/lexer-keywords.txt" + {"i64x2.le_s", TokenType::Binary, Opcode::I64X2LeS}, + {""}, {""}, {""}, +#line 394 "src/lexer-keywords.txt" + {"i64.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I64AtomicRmwAnd}, +#line 257 "src/lexer-keywords.txt" + {"i32.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I32AtomicRmwAnd}, +#line 465 "src/lexer-keywords.txt" + {"i64x2.gt_s", TokenType::Binary, Opcode::I64X2GtS}, + {""}, +#line 464 "src/lexer-keywords.txt" + {"i64x2.lt_s", TokenType::Binary, Opcode::I64X2LtS}, + {""}, {""}, {""}, {""}, +#line 558 "src/lexer-keywords.txt" + {"ref.is_null", TokenType::RefIsNull, Opcode::RefIsNull}, +#line 50 "src/lexer-keywords.txt" + {"tag", TokenType::Tag}, +#line 427 "src/lexer-keywords.txt" + {"i64.load8_u", TokenType::Load, Opcode::I64Load8U}, +#line 284 "src/lexer-keywords.txt" + {"i32.load8_u", TokenType::Load, Opcode::I32Load8U}, +#line 426 "src/lexer-keywords.txt" + {"i64.load8_s", TokenType::Load, Opcode::I64Load8S}, +#line 283 "src/lexer-keywords.txt" + {"i32.load8_s", TokenType::Load, Opcode::I32Load8S}, + {""}, {""}, +#line 106 "src/lexer-keywords.txt" + {"f32x4.relaxed_max", TokenType::Binary, Opcode::F32X4RelaxedMax}, + {""}, +#line 160 "src/lexer-keywords.txt" + {"f64x2.nearest", TokenType::Unary, Opcode::F64X2Nearest}, + {""}, +#line 159 "src/lexer-keywords.txt" + {"f64x2.mul", TokenType::Binary, Opcode::F64X2Mul}, +#line 181 "src/lexer-keywords.txt" + {"get", TokenType::Get}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 461 "src/lexer-keywords.txt" + {"i64x2.mul", TokenType::Binary, Opcode::I64X2Mul}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 393 "src/lexer-keywords.txt" + {"i64.atomic.rmw.add", TokenType::AtomicRmw, Opcode::I64AtomicRmwAdd}, +#line 256 "src/lexer-keywords.txt" + {"i32.atomic.rmw.add", TokenType::AtomicRmw, Opcode::I32AtomicRmwAdd}, + {""}, +#line 148 "src/lexer-keywords.txt" + {"f64x2.ceil", TokenType::Unary, Opcode::F64X2Ceil}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 440 "src/lexer-keywords.txt" + {"i64.shl", TokenType::Binary, Opcode::I64Shl}, +#line 297 "src/lexer-keywords.txt" + {"i32.shl", TokenType::Binary, Opcode::I32Shl}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 173 "src/lexer-keywords.txt" + {"f64x2.trunc", TokenType::Unary, Opcode::F64X2Trunc}, + {""}, +#line 338 "src/lexer-keywords.txt" + {"i32x4.min_u", TokenType::Binary, Opcode::I32X4MinU}, + {""}, +#line 337 "src/lexer-keywords.txt" + {"i32x4.min_s", TokenType::Binary, Opcode::I32X4MinS}, + {""}, +#line 345 "src/lexer-keywords.txt" + {"i32x4.shl", TokenType::Binary, Opcode::I32X4Shl}, + {""}, {""}, +#line 444 "src/lexer-keywords.txt" + {"i64.store32", TokenType::Store, Opcode::I64Store32}, +#line 548 "src/lexer-keywords.txt" + {"nan:arithmetic", TokenType::NanArithmetic}, + {""}, {""}, +#line 413 "src/lexer-keywords.txt" + {"i64.extend8_s", TokenType::Unary, Opcode::I64Extend8S}, +#line 274 "src/lexer-keywords.txt" + {"i32.extend8_s", TokenType::Unary, Opcode::I32Extend8S}, + {""}, {""}, {""}, {""}, {""}, +#line 560 "src/lexer-keywords.txt" + {"register", TokenType::Register}, + {""}, +#line 549 "src/lexer-keywords.txt" + {"nan:canonical", TokenType::NanCanonical}, + {""}, +#line 213 "src/lexer-keywords.txt" + {"i16x8.neg", TokenType::Unary, Opcode::I16X8Neg}, +#line 147 "src/lexer-keywords.txt" + {"f64x2.add", TokenType::Binary, Opcode::F64X2Add}, +#line 197 "src/lexer-keywords.txt" + {"i16x8.ge_u", TokenType::Compare, Opcode::I16X8GeU}, +#line 215 "src/lexer-keywords.txt" + {"i16x8.ne", TokenType::Compare, Opcode::I16X8Ne}, +#line 201 "src/lexer-keywords.txt" + {"i16x8.le_u", TokenType::Compare, Opcode::I16X8LeU}, + {""}, +#line 196 "src/lexer-keywords.txt" + {"i16x8.ge_s", TokenType::Compare, Opcode::I16X8GeS}, + {""}, +#line 200 "src/lexer-keywords.txt" + {"i16x8.le_s", TokenType::Compare, Opcode::I16X8LeS}, +#line 457 "src/lexer-keywords.txt" + {"i64x2.add", TokenType::Binary, Opcode::I64X2Add}, +#line 199 "src/lexer-keywords.txt" + {"i16x8.gt_u", TokenType::Compare, Opcode::I16X8GtU}, + {""}, +#line 205 "src/lexer-keywords.txt" + {"i16x8.lt_u", TokenType::Compare, Opcode::I16X8LtU}, +#line 385 "src/lexer-keywords.txt" + {"i64.atomic.rmw32.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XorU}, +#line 198 "src/lexer-keywords.txt" + {"i16x8.gt_s", TokenType::Compare, Opcode::I16X8GtS}, +#line 169 "src/lexer-keywords.txt" + {"f64x2.replace_lane", TokenType::SimdLaneOp, Opcode::F64X2ReplaceLane}, +#line 204 "src/lexer-keywords.txt" + {"i16x8.lt_s", TokenType::Compare, Opcode::I16X8LtS}, +#line 384 "src/lexer-keywords.txt" + {"i64.atomic.rmw32.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XchgU}, + {""}, +#line 387 "src/lexer-keywords.txt" + {"i64.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8AndU}, +#line 250 "src/lexer-keywords.txt" + {"i32.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8AndU}, +#line 580 "src/lexer-keywords.txt" + {"try", TokenType::Try, Opcode::Try}, + {""}, +#line 477 "src/lexer-keywords.txt" + {"i64x2.replace_lane", TokenType::SimdLaneOp, Opcode::I64X2ReplaceLane}, + {""}, +#line 530 "src/lexer-keywords.txt" + {"invoke", TokenType::Invoke}, + {""}, {""}, {""}, +#line 167 "src/lexer-keywords.txt" + {"f64x2.relaxed_min", TokenType::Binary, Opcode::F64X2RelaxedMin}, + {""}, +#line 402 "src/lexer-keywords.txt" + {"i64.atomic.store8", TokenType::AtomicStore, Opcode::I64AtomicStore8}, +#line 264 "src/lexer-keywords.txt" + {"i32.atomic.store8", TokenType::AtomicStore, Opcode::I32AtomicStore8}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 210 "src/lexer-keywords.txt" + {"i16x8.mul", TokenType::Binary, Opcode::I16X8Mul}, + {""}, +#line 425 "src/lexer-keywords.txt" + {"i64.load32_u", TokenType::Load, Opcode::I64Load32U}, + {""}, +#line 423 "src/lexer-keywords.txt" + {"i64.load16_u", TokenType::Load, Opcode::I64Load16U}, +#line 282 "src/lexer-keywords.txt" + {"i32.load16_u", TokenType::Load, Opcode::I32Load16U}, +#line 424 "src/lexer-keywords.txt" + {"i64.load32_s", TokenType::Load, Opcode::I64Load32S}, + {""}, +#line 422 "src/lexer-keywords.txt" + {"i64.load16_s", TokenType::Load, Opcode::I64Load16S}, +#line 281 "src/lexer-keywords.txt" + {"i32.load16_s", TokenType::Load, Opcode::I32Load16S}, + {""}, {""}, {""}, {""}, +#line 386 "src/lexer-keywords.txt" + {"i64.atomic.rmw8.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8AddU}, +#line 249 "src/lexer-keywords.txt" + {"i32.atomic.rmw8.add_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8AddU}, + {""}, {""}, {""}, {""}, {""}, +#line 589 "src/lexer-keywords.txt" + {"v128.or", TokenType::Binary, Opcode::V128Or}, + {""}, {""}, +#line 158 "src/lexer-keywords.txt" + {"f64x2.min", TokenType::Binary, Opcode::F64X2Min}, + {""}, {""}, +#line 527 "src/lexer-keywords.txt" + {"if", TokenType::If, Opcode::If}, +#line 232 "src/lexer-keywords.txt" + {"i16x8", TokenType::I16X8}, +#line 554 "src/lexer-keywords.txt" + {"ref", TokenType::Ref}, +#line 594 "src/lexer-keywords.txt" + {"v128", Type::V128}, + {""}, {""}, {""}, +#line 578 "src/lexer-keywords.txt" + {"then", TokenType::Then}, + {""}, {""}, {""}, +#line 370 "src/lexer-keywords.txt" + {"i64.atomic.load8_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad8U}, +#line 240 "src/lexer-keywords.txt" + {"i32.atomic.load8_u", TokenType::AtomicLoad, Opcode::I32AtomicLoad8U}, +#line 157 "src/lexer-keywords.txt" + {"f64x2.max", TokenType::Binary, Opcode::F64X2Max}, + {""}, +#line 476 "src/lexer-keywords.txt" + {"i64x2.relaxed_laneselect", TokenType::Ternary, Opcode::I64X2RelaxedLaneSelect}, + {""}, +#line 48 "src/lexer-keywords.txt" + {"else", TokenType::Else, Opcode::Else}, +#line 588 "src/lexer-keywords.txt" + {"v128.not", TokenType::Unary, Opcode::V128Not}, +#line 593 "src/lexer-keywords.txt" + {"v128.store", TokenType::Store, Opcode::V128Store}, + {""}, +#line 544 "src/lexer-keywords.txt" + {"memory.size", TokenType::MemorySize, Opcode::MemorySize}, + {""}, {""}, +#line 328 "src/lexer-keywords.txt" + {"i32x4.relaxed_trunc_f32x4_u", TokenType::Unary, Opcode::I32X4RelaxedTruncF32X4U}, + {""}, {""}, +#line 412 "src/lexer-keywords.txt" + {"i64.extend32_s", TokenType::Unary, Opcode::I64Extend32S}, +#line 327 "src/lexer-keywords.txt" + {"i32x4.relaxed_trunc_f32x4_s", TokenType::Unary, Opcode::I32X4RelaxedTruncF32X4S}, +#line 411 "src/lexer-keywords.txt" + {"i64.extend16_s", TokenType::Unary, Opcode::I64Extend16S}, +#line 273 "src/lexer-keywords.txt" + {"i32.extend16_s", TokenType::Unary, Opcode::I32Extend16S}, + {""}, {""}, {""}, +#line 188 "src/lexer-keywords.txt" + {"i16x8.add", TokenType::Binary, Opcode::I16X8Add}, +#line 45 "src/lexer-keywords.txt" + {"either", TokenType::Either}, +#line 51 "src/lexer-keywords.txt" + {"extern", Type::ExternRef, TokenType::Extern}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 49 "src/lexer-keywords.txt" + {"end", TokenType::End, Opcode::End}, + {""}, +#line 218 "src/lexer-keywords.txt" + {"i16x8.replace_lane", TokenType::SimdLaneOp, Opcode::I16X8ReplaceLane}, +#line 584 "src/lexer-keywords.txt" + {"v128.and", TokenType::Binary, Opcode::V128And}, +#line 415 "src/lexer-keywords.txt" + {"i64.extend_i32_u", TokenType::Convert, Opcode::I64ExtendI32U}, + {""}, +#line 414 "src/lexer-keywords.txt" + {"i64.extend_i32_s", TokenType::Convert, Opcode::I64ExtendI32S}, + {""}, +#line 392 "src/lexer-keywords.txt" + {"i64.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XorU}, +#line 255 "src/lexer-keywords.txt" + {"i32.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XorU}, + {""}, {""}, +#line 531 "src/lexer-keywords.txt" + {"item", TokenType::Item}, + {""}, +#line 151 "src/lexer-keywords.txt" + {"f64x2.extract_lane", TokenType::SimdLaneOp, Opcode::F64X2ExtractLane}, +#line 587 "src/lexer-keywords.txt" + {"v128.load", TokenType::Load, Opcode::V128Load}, + {""}, {""}, {""}, {""}, +#line 34 "src/lexer-keywords.txt" + {"call_indirect", TokenType::CallIndirect, Opcode::CallIndirect}, + {""}, +#line 458 "src/lexer-keywords.txt" + {"i64x2.extract_lane", TokenType::SimdLaneOp, Opcode::I64X2ExtractLane}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 168 "src/lexer-keywords.txt" + {"f64x2.relaxed_nmadd", TokenType::Ternary, Opcode::F64X2RelaxedNmadd}, +#line 89 "src/lexer-keywords.txt" + {"f32x4.div", TokenType::Binary, Opcode::F32X4Div}, + {""}, {""}, +#line 586 "src/lexer-keywords.txt" + {"v128.const", TokenType::Const, Opcode::V128Const}, + {""}, {""}, +#line 165 "src/lexer-keywords.txt" + {"f64x2.relaxed_madd", TokenType::Ternary, Opcode::F64X2RelaxedMadd}, + {""}, +#line 607 "src/lexer-keywords.txt" + {"v128.store64_lane", TokenType::SimdStoreLane, Opcode::V128Store64Lane}, +#line 583 "src/lexer-keywords.txt" + {"v128.andnot", TokenType::Binary, Opcode::V128Andnot}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 178 "src/lexer-keywords.txt" + {"field", TokenType::Field}, + {""}, {""}, +#line 451 "src/lexer-keywords.txt" + {"i64.trunc_f64_u", TokenType::Convert, Opcode::I64TruncF64U}, +#line 307 "src/lexer-keywords.txt" + {"i32.trunc_f64_u", TokenType::Convert, Opcode::I32TruncF64U}, + {""}, {""}, +#line 450 "src/lexer-keywords.txt" + {"i64.trunc_f64_s", TokenType::Convert, Opcode::I64TruncF64S}, +#line 306 "src/lexer-keywords.txt" + {"i32.trunc_f64_s", TokenType::Convert, Opcode::I32TruncF64S}, +#line 470 "src/lexer-keywords.txt" + {"i64x2.all_true", TokenType::Unary, Opcode::I64X2AllTrue}, + {""}, {""}, {""}, {""}, {""}, +#line 216 "src/lexer-keywords.txt" + {"i16x8.relaxed_laneselect", TokenType::Ternary, Opcode::I16X8RelaxedLaneSelect}, + {""}, {""}, {""}, {""}, {""}, +#line 177 "src/lexer-keywords.txt" + {"f64x2", TokenType::F64X2}, + {""}, +#line 92 "src/lexer-keywords.txt" + {"f32x4.floor", TokenType::Unary, Opcode::F32X4Floor}, +#line 595 "src/lexer-keywords.txt" + {"v128.xor", TokenType::Binary, Opcode::V128Xor}, + {""}, {""}, {""}, {""}, +#line 487 "src/lexer-keywords.txt" + {"i64x2", TokenType::I64X2}, + {""}, {""}, +#line 442 "src/lexer-keywords.txt" + {"i64.shr_u", TokenType::Binary, Opcode::I64ShrU}, +#line 299 "src/lexer-keywords.txt" + {"i32.shr_u", TokenType::Binary, Opcode::I32ShrU}, +#line 441 "src/lexer-keywords.txt" + {"i64.shr_s", TokenType::Binary, Opcode::I64ShrS}, +#line 298 "src/lexer-keywords.txt" + {"i32.shr_s", TokenType::Binary, Opcode::I32ShrS}, + {""}, {""}, {""}, {""}, {""}, +#line 347 "src/lexer-keywords.txt" + {"i32x4.shr_u", TokenType::Binary, Opcode::I32X4ShrU}, + {""}, +#line 346 "src/lexer-keywords.txt" + {"i32x4.shr_s", TokenType::Binary, Opcode::I32X4ShrS}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, +#line 557 "src/lexer-keywords.txt" + {"ref.func", TokenType::RefFunc, Opcode::RefFunc}, + {""}, {""}, {""}, +#line 389 "src/lexer-keywords.txt" + {"i64.atomic.rmw8.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8OrU}, +#line 252 "src/lexer-keywords.txt" + {"i32.atomic.rmw8.or_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8OrU}, + {""}, {""}, {""}, {""}, +#line 127 "src/lexer-keywords.txt" + {"f64.floor", TokenType::Unary, Opcode::F64Floor}, +#line 66 "src/lexer-keywords.txt" + {"f32.floor", TokenType::Unary, Opcode::F32Floor}, + {""}, +#line 600 "src/lexer-keywords.txt" + {"v128.load8_lane", TokenType::SimdLoadLane, Opcode::V128Load8Lane}, + {""}, +#line 460 "src/lexer-keywords.txt" + {"v128.load32x2_u", TokenType::Load, Opcode::V128Load32X2U}, + {""}, {""}, {""}, +#line 459 "src/lexer-keywords.txt" + {"v128.load32x2_s", TokenType::Load, Opcode::V128Load32X2S}, + {""}, {""}, {""}, +#line 563 "src/lexer-keywords.txt" + {"return_call_indirect", TokenType::ReturnCallIndirect, Opcode::ReturnCallIndirect}, +#line 543 "src/lexer-keywords.txt" + {"memory.init", TokenType::MemoryInit, Opcode::MemoryInit}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 166 "src/lexer-keywords.txt" + {"f64x2.relaxed_max", TokenType::Binary, Opcode::F64X2RelaxedMax}, + {""}, {""}, +#line 38 "src/lexer-keywords.txt" + {"catch_all", TokenType::CatchAll, Opcode::CatchAll}, +#line 112 "src/lexer-keywords.txt" + {"f32x4.sub", TokenType::Binary, Opcode::F32X4Sub}, + {""}, +#line 568 "src/lexer-keywords.txt" + {"start", TokenType::Start}, + {""}, {""}, {""}, {""}, {""}, +#line 349 "src/lexer-keywords.txt" + {"i32x4.sub", TokenType::Binary, Opcode::I32X4Sub}, +#line 224 "src/lexer-keywords.txt" + {"i16x8.sub_sat_u", TokenType::Binary, Opcode::I16X8SubSatU}, +#line 599 "src/lexer-keywords.txt" + {"v128.load8_splat", TokenType::Load, Opcode::V128Load8Splat}, + {""}, +#line 189 "src/lexer-keywords.txt" + {"i16x8.all_true", TokenType::Unary, Opcode::I16X8AllTrue}, +#line 223 "src/lexer-keywords.txt" + {"i16x8.sub_sat_s", TokenType::Binary, Opcode::I16X8SubSatS}, +#line 116 "src/lexer-keywords.txt" + {"f64.abs", TokenType::Unary, Opcode::F64Abs}, +#line 54 "src/lexer-keywords.txt" + {"f32.abs", TokenType::Unary, Opcode::F32Abs}, + {""}, {""}, {""}, {""}, {""}, +#line 581 "src/lexer-keywords.txt" + {"type", TokenType::Type}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 84 "src/lexer-keywords.txt" + {"f32x4.abs", TokenType::Unary, Opcode::F32X4Abs}, + {""}, {""}, +#line 398 "src/lexer-keywords.txt" + {"i64.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I64AtomicRmwXchg}, +#line 261 "src/lexer-keywords.txt" + {"i32.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I32AtomicRmwXchg}, +#line 63 "src/lexer-keywords.txt" + {"f32.demote_f64", TokenType::Convert, Opcode::F32DemoteF64}, + {""}, {""}, +#line 314 "src/lexer-keywords.txt" + {"i32x4.abs", TokenType::Unary, Opcode::I32X4Abs}, + {""}, +#line 207 "src/lexer-keywords.txt" + {"i16x8.max_u", TokenType::Binary, Opcode::I16X8MaxU}, + {""}, +#line 206 "src/lexer-keywords.txt" + {"i16x8.max_s", TokenType::Binary, Opcode::I16X8MaxS}, +#line 571 "src/lexer-keywords.txt" + {"table.fill", TokenType::TableFill, Opcode::TableFill}, +#line 478 "src/lexer-keywords.txt" + {"i64x2.shl", TokenType::Binary, Opcode::I64X2Shl}, + {""}, +#line 513 "src/lexer-keywords.txt" + {"i8x16.neg", TokenType::Unary, Opcode::I8X16Neg}, + {""}, +#line 500 "src/lexer-keywords.txt" + {"i8x16.ge_u", TokenType::Compare, Opcode::I8X16GeU}, +#line 515 "src/lexer-keywords.txt" + {"i8x16.ne", TokenType::Compare, Opcode::I8X16Ne}, +#line 504 "src/lexer-keywords.txt" + {"i8x16.le_u", TokenType::Compare, Opcode::I8X16LeU}, + {""}, +#line 499 "src/lexer-keywords.txt" + {"i8x16.ge_s", TokenType::Compare, Opcode::I8X16GeS}, + {""}, +#line 503 "src/lexer-keywords.txt" + {"i8x16.le_s", TokenType::Compare, Opcode::I8X16LeS}, + {""}, +#line 502 "src/lexer-keywords.txt" + {"i8x16.gt_u", TokenType::Compare, Opcode::I8X16GtU}, + {""}, +#line 506 "src/lexer-keywords.txt" + {"i8x16.lt_u", TokenType::Compare, Opcode::I8X16LtU}, +#line 529 "src/lexer-keywords.txt" + {"input", TokenType::Input}, +#line 501 "src/lexer-keywords.txt" + {"i8x16.gt_s", TokenType::Compare, Opcode::I8X16GtS}, + {""}, +#line 505 "src/lexer-keywords.txt" + {"i8x16.lt_s", TokenType::Compare, Opcode::I8X16LtS}, + {""}, {""}, +#line 203 "src/lexer-keywords.txt" + {"v128.load8x8_u", TokenType::Load, Opcode::V128Load8X8U}, + {""}, +#line 202 "src/lexer-keywords.txt" + {"v128.load8x8_s", TokenType::Load, Opcode::V128Load8X8S}, + {""}, {""}, {""}, +#line 555 "src/lexer-keywords.txt" + {"quote", TokenType::Quote}, + {""}, {""}, +#line 528 "src/lexer-keywords.txt" + {"import", TokenType::Import}, + {""}, +#line 567 "src/lexer-keywords.txt" + {"shared", TokenType::Shared}, +#line 604 "src/lexer-keywords.txt" + {"v128.store8_lane", TokenType::SimdStoreLane, Opcode::V128Store8Lane}, + {""}, +#line 187 "src/lexer-keywords.txt" + {"i16x8.add_sat_u", TokenType::Binary, Opcode::I16X8AddSatU}, + {""}, {""}, {""}, +#line 186 "src/lexer-keywords.txt" + {"i16x8.add_sat_s", TokenType::Binary, Opcode::I16X8AddSatS}, +#line 141 "src/lexer-keywords.txt" + {"f64.sqrt", TokenType::Unary, Opcode::F64Sqrt}, +#line 79 "src/lexer-keywords.txt" + {"f32.sqrt", TokenType::Unary, Opcode::F32Sqrt}, +#line 32 "src/lexer-keywords.txt" + {"br_table", TokenType::BrTable, Opcode::BrTable}, + {""}, +#line 552 "src/lexer-keywords.txt" + {"output", TokenType::Output}, + {""}, +#line 602 "src/lexer-keywords.txt" + {"v128.load32_lane", TokenType::SimdLoadLane, Opcode::V128Load32Lane}, + {""}, +#line 551 "src/lexer-keywords.txt" + {"offset", TokenType::Offset}, +#line 111 "src/lexer-keywords.txt" + {"f32x4.sqrt", TokenType::Unary, Opcode::F32X4Sqrt}, + {""}, {""}, +#line 545 "src/lexer-keywords.txt" + {"memory", TokenType::Memory}, +#line 381 "src/lexer-keywords.txt" + {"i64.atomic.rmw32.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw32CmpxchgU}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 123 "src/lexer-keywords.txt" + {"f64.convert_i64_u", TokenType::Convert, Opcode::F64ConvertI64U}, +#line 61 "src/lexer-keywords.txt" + {"f32.convert_i64_u", TokenType::Convert, Opcode::F32ConvertI64U}, + {""}, {""}, +#line 122 "src/lexer-keywords.txt" + {"f64.convert_i64_s", TokenType::Convert, Opcode::F64ConvertI64S}, +#line 60 "src/lexer-keywords.txt" + {"f32.convert_i64_s", TokenType::Convert, Opcode::F32ConvertI64S}, +#line 408 "src/lexer-keywords.txt" + {"i64.div_u", TokenType::Binary, Opcode::I64DivU}, +#line 270 "src/lexer-keywords.txt" + {"i32.div_u", TokenType::Binary, Opcode::I32DivU}, +#line 407 "src/lexer-keywords.txt" + {"i64.div_s", TokenType::Binary, Opcode::I64DivS}, +#line 269 "src/lexer-keywords.txt" + {"i32.div_s", TokenType::Binary, Opcode::I32DivS}, +#line 597 "src/lexer-keywords.txt" + {"v128.load32_splat", TokenType::Load, Opcode::V128Load32Splat}, + {""}, {""}, {""}, +#line 376 "src/lexer-keywords.txt" + {"i64.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16SubU}, +#line 246 "src/lexer-keywords.txt" + {"i32.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16SubU}, + {""}, {""}, {""}, +#line 37 "src/lexer-keywords.txt" + {"catch", TokenType::Catch, Opcode::Catch}, + {""}, {""}, {""}, +#line 553 "src/lexer-keywords.txt" + {"param", TokenType::Param}, + {""}, {""}, {""}, {""}, {""}, +#line 209 "src/lexer-keywords.txt" + {"i16x8.min_u", TokenType::Binary, Opcode::I16X8MinU}, + {""}, +#line 208 "src/lexer-keywords.txt" + {"i16x8.min_s", TokenType::Binary, Opcode::I16X8MinS}, + {""}, +#line 219 "src/lexer-keywords.txt" + {"i16x8.shl", TokenType::Binary, Opcode::I16X8Shl}, + {""}, +#line 110 "src/lexer-keywords.txt" + {"f32x4.splat", TokenType::Unary, Opcode::F32X4Splat}, + {""}, {""}, {""}, {""}, +#line 591 "src/lexer-keywords.txt" + {"v128.load32_zero", TokenType::Load, Opcode::V128Load32Zero}, + {""}, {""}, +#line 348 "src/lexer-keywords.txt" + {"i32x4.splat", TokenType::Unary, Opcode::I32X4Splat}, +#line 492 "src/lexer-keywords.txt" + {"i8x16.add", TokenType::Binary, Opcode::I8X16Add}, + {""}, +#line 373 "src/lexer-keywords.txt" + {"i64.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AndU}, +#line 243 "src/lexer-keywords.txt" + {"i32.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AndU}, + {""}, {""}, {""}, +#line 579 "src/lexer-keywords.txt" + {"throw", TokenType::Throw, Opcode::Throw}, +#line 369 "src/lexer-keywords.txt" + {"i64.atomic.load32_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad32U}, +#line 104 "src/lexer-keywords.txt" + {"f32x4.pmin", TokenType::Binary, Opcode::F32X4PMin}, +#line 368 "src/lexer-keywords.txt" + {"i64.atomic.load16_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad16U}, +#line 239 "src/lexer-keywords.txt" + {"i32.atomic.load16_u", TokenType::AtomicLoad, Opcode::I32AtomicLoad16U}, + {""}, {""}, +#line 518 "src/lexer-keywords.txt" + {"i8x16.replace_lane", TokenType::SimdLaneOp, Opcode::I8X16ReplaceLane}, +#line 30 "src/lexer-keywords.txt" + {"block", TokenType::Block, Opcode::Block}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 375 "src/lexer-keywords.txt" + {"i64.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16OrU}, +#line 245 "src/lexer-keywords.txt" + {"i32.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16OrU}, + {""}, {""}, {""}, {""}, {""}, +#line 372 "src/lexer-keywords.txt" + {"i64.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AddU}, +#line 242 "src/lexer-keywords.txt" + {"i32.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AddU}, + {""}, {""}, {""}, +#line 39 "src/lexer-keywords.txt" + {"data.drop", TokenType::DataDrop, Opcode::DataDrop}, + {""}, {""}, +#line 29 "src/lexer-keywords.txt" + {"binary", TokenType::Bin}, + {""}, {""}, +#line 190 "src/lexer-keywords.txt" + {"i16x8.avgr_u", TokenType::Binary, Opcode::I16X8AvgrU}, +#line 195 "src/lexer-keywords.txt" + {"i16x8.extract_lane_u", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneU}, + {""}, +#line 194 "src/lexer-keywords.txt" + {"i16x8.extract_lane_s", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneS}, + {""}, {""}, {""}, {""}, +#line 590 "src/lexer-keywords.txt" + {"v128.any_true", TokenType::Unary, Opcode::V128AnyTrue}, + {""}, +#line 149 "src/lexer-keywords.txt" + {"f64x2.div", TokenType::Binary, Opcode::F64X2Div}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 606 "src/lexer-keywords.txt" + {"v128.store32_lane", TokenType::SimdStoreLane, Opcode::V128Store32Lane}, + {""}, +#line 605 "src/lexer-keywords.txt" + {"v128.store16_lane", TokenType::SimdStoreLane, Opcode::V128Store16Lane}, +#line 401 "src/lexer-keywords.txt" + {"i64.atomic.store32", TokenType::AtomicStore, Opcode::I64AtomicStore32}, + {""}, +#line 542 "src/lexer-keywords.txt" + {"memory.grow", TokenType::MemoryGrow, Opcode::MemoryGrow}, +#line 517 "src/lexer-keywords.txt" + {"i8x16.relaxed_laneselect", TokenType::Ternary, Opcode::I8X16RelaxedLaneSelect}, + {""}, {""}, +#line 317 "src/lexer-keywords.txt" + {"i32x4.bitmask", TokenType::Unary, Opcode::I32X4Bitmask}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 562 "src/lexer-keywords.txt" + {"rethrow", TokenType::Rethrow, Opcode::Rethrow}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 582 "src/lexer-keywords.txt" + {"unreachable", TokenType::Unreachable, Opcode::Unreachable}, + {""}, +#line 152 "src/lexer-keywords.txt" + {"f64x2.floor", TokenType::Unary, Opcode::F64X2Floor}, + {""}, {""}, {""}, +#line 573 "src/lexer-keywords.txt" + {"table.grow", TokenType::TableGrow, Opcode::TableGrow}, +#line 410 "src/lexer-keywords.txt" + {"i64.eqz", TokenType::Convert, Opcode::I64Eqz}, +#line 272 "src/lexer-keywords.txt" + {"i32.eqz", TokenType::Convert, Opcode::I32Eqz}, + {""}, {""}, +#line 391 "src/lexer-keywords.txt" + {"i64.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XchgU}, +#line 254 "src/lexer-keywords.txt" + {"i32.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XchgU}, + {""}, {""}, {""}, {""}, {""}, +#line 443 "src/lexer-keywords.txt" + {"i64.store16", TokenType::Store, Opcode::I64Store16}, +#line 300 "src/lexer-keywords.txt" + {"i32.store16", TokenType::Store, Opcode::I32Store16}, +#line 480 "src/lexer-keywords.txt" + {"i64x2.shr_u", TokenType::Binary, Opcode::I64X2ShrU}, + {""}, +#line 479 "src/lexer-keywords.txt" + {"i64x2.shr_s", TokenType::Binary, Opcode::I64X2ShrS}, + {""}, {""}, +#line 570 "src/lexer-keywords.txt" + {"table.copy", TokenType::TableCopy, Opcode::TableCopy}, + {""}, +#line 541 "src/lexer-keywords.txt" + {"memory.fill", TokenType::MemoryFill, Opcode::MemoryFill}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, +#line 125 "src/lexer-keywords.txt" + {"f64.div", TokenType::Binary, Opcode::F64Div}, +#line 64 "src/lexer-keywords.txt" + {"f32.div", TokenType::Binary, Opcode::F32Div}, + {""}, +#line 25 "src/lexer-keywords.txt" + {"assert_return", TokenType::AssertReturn}, +#line 378 "src/lexer-keywords.txt" + {"i64.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XorU}, +#line 248 "src/lexer-keywords.txt" + {"i32.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XorU}, + {""}, {""}, +#line 377 "src/lexer-keywords.txt" + {"i64.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XchgU}, +#line 247 "src/lexer-keywords.txt" + {"i32.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XchgU}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, +#line 524 "src/lexer-keywords.txt" + {"i8x16.sub_sat_u", TokenType::Binary, Opcode::I8X16SubSatU}, + {""}, {""}, +#line 493 "src/lexer-keywords.txt" + {"i8x16.all_true", TokenType::Unary, Opcode::I8X16AllTrue}, +#line 523 "src/lexer-keywords.txt" + {"i8x16.sub_sat_s", TokenType::Binary, Opcode::I8X16SubSatS}, + {""}, {""}, +#line 172 "src/lexer-keywords.txt" + {"f64x2.sub", TokenType::Binary, Opcode::F64X2Sub}, + {""}, {""}, {""}, {""}, +#line 339 "src/lexer-keywords.txt" + {"i32x4.dot_i16x8_s", TokenType::Binary, Opcode::I32X4DotI16X8S}, + {""}, {""}, +#line 482 "src/lexer-keywords.txt" + {"i64x2.sub", TokenType::Binary, Opcode::I64X2Sub}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 526 "src/lexer-keywords.txt" + {"i8x16", TokenType::I8X16}, + {""}, {""}, {""}, +#line 508 "src/lexer-keywords.txt" + {"i8x16.max_u", TokenType::Binary, Opcode::I8X16MaxU}, + {""}, +#line 507 "src/lexer-keywords.txt" + {"i8x16.max_s", TokenType::Binary, Opcode::I8X16MaxS}, + {""}, {""}, {""}, +#line 146 "src/lexer-keywords.txt" + {"f64x2.abs", TokenType::Unary, Opcode::F64X2Abs}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 468 "src/lexer-keywords.txt" + {"i64x2.abs", TokenType::Unary, Opcode::I64X2Abs}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 221 "src/lexer-keywords.txt" + {"i16x8.shr_u", TokenType::Binary, Opcode::I16X8ShrU}, + {""}, +#line 220 "src/lexer-keywords.txt" + {"i16x8.shr_s", TokenType::Binary, Opcode::I16X8ShrS}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 390 "src/lexer-keywords.txt" + {"i64.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8SubU}, +#line 253 "src/lexer-keywords.txt" + {"i32.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8SubU}, + {""}, {""}, {""}, {""}, {""}, +#line 491 "src/lexer-keywords.txt" + {"i8x16.add_sat_u", TokenType::Binary, Opcode::I8X16AddSatU}, +#line 103 "src/lexer-keywords.txt" + {"f32x4.pmax", TokenType::Binary, Opcode::F32X4PMax}, + {""}, {""}, +#line 490 "src/lexer-keywords.txt" + {"i8x16.add_sat_s", TokenType::Binary, Opcode::I8X16AddSatS}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, +#line 455 "src/lexer-keywords.txt" + {"i64.trunc_sat_f64_u", TokenType::Convert, Opcode::I64TruncSatF64U}, +#line 311 "src/lexer-keywords.txt" + {"i32.trunc_sat_f64_u", TokenType::Convert, Opcode::I32TruncSatF64U}, +#line 47 "src/lexer-keywords.txt" + {"elem", TokenType::Elem}, + {""}, +#line 454 "src/lexer-keywords.txt" + {"i64.trunc_sat_f64_s", TokenType::Convert, Opcode::I64TruncSatF64S}, +#line 310 "src/lexer-keywords.txt" + {"i32.trunc_sat_f64_s", TokenType::Convert, Opcode::I32TruncSatF64S}, +#line 171 "src/lexer-keywords.txt" + {"f64x2.sqrt", TokenType::Unary, Opcode::F64X2Sqrt}, + {""}, {""}, {""}, +#line 52 "src/lexer-keywords.txt" + {"externref", Type::ExternRef}, +#line 603 "src/lexer-keywords.txt" + {"v128.load64_lane", TokenType::SimdLoadLane, Opcode::V128Load64Lane}, + {""}, +#line 351 "src/lexer-keywords.txt" + {"i32x4.extadd_pairwise_i16x8_u", TokenType::Unary, Opcode::I32X4ExtaddPairwiseI16X8U}, + {""}, +#line 350 "src/lexer-keywords.txt" + {"i32x4.extadd_pairwise_i16x8_s", TokenType::Unary, Opcode::I32X4ExtaddPairwiseI16X8S}, +#line 225 "src/lexer-keywords.txt" + {"i16x8.sub", TokenType::Binary, Opcode::I16X8Sub}, +#line 31 "src/lexer-keywords.txt" + {"br_if", TokenType::BrIf, Opcode::BrIf}, +#line 121 "src/lexer-keywords.txt" + {"f64.convert_i32_u", TokenType::Convert, Opcode::F64ConvertI32U}, +#line 59 "src/lexer-keywords.txt" + {"f32.convert_i32_u", TokenType::Convert, Opcode::F32ConvertI32U}, + {""}, +#line 24 "src/lexer-keywords.txt" + {"assert_malformed", TokenType::AssertMalformed}, +#line 120 "src/lexer-keywords.txt" + {"f64.convert_i32_s", TokenType::Convert, Opcode::F64ConvertI32S}, +#line 58 "src/lexer-keywords.txt" + {"f32.convert_i32_s", TokenType::Convert, Opcode::F32ConvertI32S}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 510 "src/lexer-keywords.txt" + {"i8x16.min_u", TokenType::Binary, Opcode::I8X16MinU}, + {""}, +#line 509 "src/lexer-keywords.txt" + {"i8x16.min_s", TokenType::Binary, Opcode::I8X16MinS}, + {""}, +#line 519 "src/lexer-keywords.txt" + {"i8x16.shl", TokenType::Binary, Opcode::I8X16Shl}, +#line 598 "src/lexer-keywords.txt" + {"v128.load64_splat", TokenType::Load, Opcode::V128Load64Splat}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 185 "src/lexer-keywords.txt" + {"i16x8.abs", TokenType::Unary, Opcode::I16X8Abs}, +#line 179 "src/lexer-keywords.txt" + {"funcref", Type::FuncRef}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 170 "src/lexer-keywords.txt" + {"f64x2.splat", TokenType::Unary, Opcode::F64X2Splat}, + {""}, {""}, {""}, {""}, {""}, +#line 516 "src/lexer-keywords.txt" + {"i8x16.relaxed_swizzle", TokenType::Binary, Opcode::I8X16RelaxedSwizzle}, + {""}, +#line 481 "src/lexer-keywords.txt" + {"i64x2.splat", TokenType::Unary, Opcode::I64X2Splat}, + {""}, {""}, {""}, {""}, +#line 592 "src/lexer-keywords.txt" + {"v128.load64_zero", TokenType::Load, Opcode::V128Load64Zero}, +#line 88 "src/lexer-keywords.txt" + {"f32x4.convert_i32x4_u", TokenType::Unary, Opcode::F32X4ConvertI32X4U}, + {""}, +#line 87 "src/lexer-keywords.txt" + {"f32x4.convert_i32x4_s", TokenType::Unary, Opcode::F32X4ConvertI32X4S}, + {""}, +#line 164 "src/lexer-keywords.txt" + {"f64x2.pmin", TokenType::Binary, Opcode::F64X2PMin}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, +#line 474 "src/lexer-keywords.txt" + {"i64x2.extend_low_i32x4_u", TokenType::Unary, Opcode::I64X2ExtendLowI32X4U}, + {""}, +#line 472 "src/lexer-keywords.txt" + {"i64x2.extend_low_i32x4_s", TokenType::Unary, Opcode::I64X2ExtendLowI32X4S}, + {""}, {""}, +#line 485 "src/lexer-keywords.txt" + {"i64x2.extmul_low_i32x4_u", TokenType::Binary, Opcode::I64X2ExtmulLowI32X4U}, +#line 184 "src/lexer-keywords.txt" + {"global", TokenType::Global}, +#line 483 "src/lexer-keywords.txt" + {"i64x2.extmul_low_i32x4_s", TokenType::Binary, Opcode::I64X2ExtmulLowI32X4S}, + {""}, {""}, +#line 494 "src/lexer-keywords.txt" + {"i8x16.avgr_u", TokenType::Binary, Opcode::I8X16AvgrU}, +#line 498 "src/lexer-keywords.txt" + {"i8x16.extract_lane_u", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneU}, + {""}, +#line 497 "src/lexer-keywords.txt" + {"i8x16.extract_lane_s", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneS}, + {""}, {""}, {""}, {""}, +#line 358 "src/lexer-keywords.txt" + {"i32x4.trunc_sat_f32x4_u", TokenType::Unary, Opcode::I32X4TruncSatF32X4U}, + {""}, {""}, {""}, +#line 357 "src/lexer-keywords.txt" + {"i32x4.trunc_sat_f32x4_s", TokenType::Unary, Opcode::I32X4TruncSatF32X4S}, +#line 332 "src/lexer-keywords.txt" + {"v128.load16x4_u", TokenType::Load, Opcode::V128Load16X4U}, + {""}, {""}, {""}, +#line 331 "src/lexer-keywords.txt" + {"v128.load16x4_s", TokenType::Load, Opcode::V128Load16X4S}, + {""}, {""}, {""}, {""}, +#line 395 "src/lexer-keywords.txt" + {"i64.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmwCmpxchg}, +#line 258 "src/lexer-keywords.txt" + {"i32.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmwCmpxchg}, + {""}, {""}, +#line 360 "src/lexer-keywords.txt" + {"i32x4.extend_high_i16x8_u", TokenType::Unary, Opcode::I32X4ExtendHighI16X8U}, + {""}, +#line 359 "src/lexer-keywords.txt" + {"i32x4.extend_high_i16x8_s", TokenType::Unary, Opcode::I32X4ExtendHighI16X8S}, + {""}, {""}, +#line 355 "src/lexer-keywords.txt" + {"i32x4.extmul_high_i16x8_u", TokenType::Binary, Opcode::I32X4ExtmulHighI16X8U}, + {""}, +#line 353 "src/lexer-keywords.txt" + {"i32x4.extmul_high_i16x8_s", TokenType::Binary, Opcode::I32X4ExtmulHighI16X8S}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 182 "src/lexer-keywords.txt" + {"global.get", TokenType::GlobalGet, Opcode::GlobalGet}, +#line 471 "src/lexer-keywords.txt" + {"i64x2.bitmask", TokenType::Unary, Opcode::I64X2Bitmask}, +#line 183 "src/lexer-keywords.txt" + {"global.set", TokenType::GlobalSet, Opcode::GlobalSet}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, +#line 222 "src/lexer-keywords.txt" + {"i16x8.splat", TokenType::Unary, Opcode::I16X8Splat}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, +#line 388 "src/lexer-keywords.txt" + {"i64.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw8CmpxchgU}, +#line 251 "src/lexer-keywords.txt" + {"i32.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw8CmpxchgU}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, +#line 114 "src/lexer-keywords.txt" + {"f32x4.demote_f64x2_zero", TokenType::Unary, Opcode::F32X4DemoteF64X2Zero}, + {""}, {""}, {""}, +#line 364 "src/lexer-keywords.txt" + {"i32x4.trunc_sat_f64x2_u_zero", TokenType::Unary, Opcode::I32X4TruncSatF64X2UZero}, + {""}, +#line 363 "src/lexer-keywords.txt" + {"i32x4.trunc_sat_f64x2_s_zero", TokenType::Unary, Opcode::I32X4TruncSatF64X2SZero}, + {""}, {""}, +#line 609 "src/lexer-keywords.txt" + {"i8x16.swizzle", TokenType::Binary, Opcode::I8X16Swizzle}, + {""}, {""}, {""}, {""}, {""}, +#line 585 "src/lexer-keywords.txt" + {"v128.bitselect", TokenType::Ternary, Opcode::V128BitSelect}, + {""}, {""}, +#line 53 "src/lexer-keywords.txt" + {"export", TokenType::Export}, +#line 212 "src/lexer-keywords.txt" + {"i16x8.narrow_i32x4_u", TokenType::Binary, Opcode::I16X8NarrowI32X4U}, + {""}, +#line 211 "src/lexer-keywords.txt" + {"i16x8.narrow_i32x4_s", TokenType::Binary, Opcode::I16X8NarrowI32X4S}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, +#line 601 "src/lexer-keywords.txt" + {"v128.load16_lane", TokenType::SimdLoadLane, Opcode::V128Load16Lane}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 374 "src/lexer-keywords.txt" + {"i64.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw16CmpxchgU}, +#line 244 "src/lexer-keywords.txt" + {"i32.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw16CmpxchgU}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 191 "src/lexer-keywords.txt" + {"i16x8.bitmask", TokenType::Unary, Opcode::I16X8Bitmask}, +#line 217 "src/lexer-keywords.txt" + {"i16x8.relaxed_q15mulr_s", TokenType::Binary, Opcode::I16X8RelaxedQ15mulrS}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 596 "src/lexer-keywords.txt" + {"v128.load16_splat", TokenType::Load, Opcode::V128Load16Splat}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, +#line 521 "src/lexer-keywords.txt" + {"i8x16.shr_u", TokenType::Binary, Opcode::I8X16ShrU}, + {""}, +#line 520 "src/lexer-keywords.txt" + {"i8x16.shr_s", TokenType::Binary, Opcode::I8X16ShrS}, + {""}, {""}, +#line 143 "src/lexer-keywords.txt" + {"f64.sub", TokenType::Binary, Opcode::F64Sub}, +#line 81 "src/lexer-keywords.txt" + {"f32.sub", TokenType::Binary, Opcode::F32Sub}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 447 "src/lexer-keywords.txt" + {"i64.sub", TokenType::Binary, Opcode::I64Sub}, +#line 303 "src/lexer-keywords.txt" + {"i32.sub", TokenType::Binary, Opcode::I32Sub}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, +#line 236 "src/lexer-keywords.txt" + {"i16x8.extend_low_i8x16_u", TokenType::Unary, Opcode::I16X8ExtendLowI8X16U}, + {""}, +#line 235 "src/lexer-keywords.txt" + {"i16x8.extend_low_i8x16_s", TokenType::Unary, Opcode::I16X8ExtendLowI8X16S}, + {""}, {""}, +#line 230 "src/lexer-keywords.txt" + {"i16x8.extmul_low_i8x16_u", TokenType::Binary, Opcode::I16X8ExtmulLowI8X16U}, + {""}, +#line 228 "src/lexer-keywords.txt" + {"i16x8.extmul_low_i8x16_s", TokenType::Binary, Opcode::I16X8ExtmulLowI8X16S}, +#line 163 "src/lexer-keywords.txt" + {"f64x2.pmax", TokenType::Binary, Opcode::F64X2PMax}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 362 "src/lexer-keywords.txt" + {"i32x4.extend_low_i16x8_u", TokenType::Unary, Opcode::I32X4ExtendLowI16X8U}, + {""}, +#line 361 "src/lexer-keywords.txt" + {"i32x4.extend_low_i16x8_s", TokenType::Unary, Opcode::I32X4ExtendLowI16X8S}, +#line 35 "src/lexer-keywords.txt" + {"call_ref", TokenType::CallRef, Opcode::CallRef}, + {""}, +#line 354 "src/lexer-keywords.txt" + {"i32x4.extmul_low_i16x8_u", TokenType::Binary, Opcode::I32X4ExtmulLowI16X8U}, + {""}, +#line 352 "src/lexer-keywords.txt" + {"i32x4.extmul_low_i16x8_s", TokenType::Binary, Opcode::I32X4ExtmulLowI16X8S}, +#line 313 "src/lexer-keywords.txt" + {"i32.wrap_i64", TokenType::Convert, Opcode::I32WrapI64}, + {""}, {""}, {""}, {""}, {""}, +#line 525 "src/lexer-keywords.txt" + {"i8x16.sub", TokenType::Binary, Opcode::I8X16Sub}, +#line 453 "src/lexer-keywords.txt" + {"i64.trunc_sat_f32_u", TokenType::Convert, Opcode::I64TruncSatF32U}, +#line 309 "src/lexer-keywords.txt" + {"i32.trunc_sat_f32_u", TokenType::Convert, Opcode::I32TruncSatF32U}, + {""}, {""}, +#line 452 "src/lexer-keywords.txt" + {"i64.trunc_sat_f32_s", TokenType::Convert, Opcode::I64TruncSatF32S}, +#line 308 "src/lexer-keywords.txt" + {"i32.trunc_sat_f32_s", TokenType::Convert, Opcode::I32TruncSatF32S}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 318 "src/lexer-keywords.txt" + {"i32x4.dot_i8x16_i7x16_add_s", TokenType::Ternary, Opcode::I32X4DotI8X16I7X16AddS}, + {""}, {""}, {""}, {""}, +#line 124 "src/lexer-keywords.txt" + {"f64.copysign", TokenType::Binary, Opcode::F64Copysign}, +#line 62 "src/lexer-keywords.txt" + {"f32.copysign", TokenType::Binary, Opcode::F32Copysign}, + {""}, {""}, +#line 475 "src/lexer-keywords.txt" + {"i64x2.extend_high_i32x4_u", TokenType::Unary, Opcode::I64X2ExtendHighI32X4U}, + {""}, +#line 473 "src/lexer-keywords.txt" + {"i64x2.extend_high_i32x4_s", TokenType::Unary, Opcode::I64X2ExtendHighI32X4S}, + {""}, {""}, +#line 486 "src/lexer-keywords.txt" + {"i64x2.extmul_high_i32x4_u", TokenType::Binary, Opcode::I64X2ExtmulHighI32X4U}, +#line 489 "src/lexer-keywords.txt" + {"i8x16.abs", TokenType::Unary, Opcode::I8X16Abs}, +#line 484 "src/lexer-keywords.txt" + {"i64x2.extmul_high_i32x4_s", TokenType::Binary, Opcode::I64X2ExtmulHighI32X4S}, + {""}, +#line 140 "src/lexer-keywords.txt" + {"f64.reinterpret_i64", TokenType::Convert, Opcode::F64ReinterpretI64}, + {""}, +#line 20 "src/lexer-keywords.txt" + {"array", Type::Array, TokenType::Array}, + {""}, {""}, {""}, {""}, +#line 400 "src/lexer-keywords.txt" + {"i64.atomic.store16", TokenType::AtomicStore, Opcode::I64AtomicStore16}, +#line 263 "src/lexer-keywords.txt" + {"i32.atomic.store16", TokenType::AtomicStore, Opcode::I32AtomicStore16}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, +#line 126 "src/lexer-keywords.txt" + {"f64.eq", TokenType::Compare, Opcode::F64Eq}, +#line 65 "src/lexer-keywords.txt" + {"f32.eq", TokenType::Compare, Opcode::F32Eq}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 409 "src/lexer-keywords.txt" + {"i64.eq", TokenType::Compare, Opcode::I64Eq}, +#line 271 "src/lexer-keywords.txt" + {"i32.eq", TokenType::Compare, Opcode::I32Eq}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, +#line 90 "src/lexer-keywords.txt" + {"f32x4.eq", TokenType::Compare, Opcode::F32X4Eq}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 319 "src/lexer-keywords.txt" + {"i32x4.eq", TokenType::Compare, Opcode::I32X4Eq}, + {""}, +#line 22 "src/lexer-keywords.txt" + {"assert_exhaustion", TokenType::AssertExhaustion}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 44 "src/lexer-keywords.txt" + {"drop", TokenType::Drop, Opcode::Drop}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, +#line 23 "src/lexer-keywords.txt" + {"assert_invalid", TokenType::AssertInvalid}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 550 "src/lexer-keywords.txt" + {"nop", TokenType::Nop, Opcode::Nop}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, +#line 522 "src/lexer-keywords.txt" + {"i8x16.splat", TokenType::Unary, Opcode::I8X16Splat}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 536 "src/lexer-keywords.txt" + {"loop", TokenType::Loop, Opcode::Loop}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 538 "src/lexer-keywords.txt" + {"memory.atomic.wait32", TokenType::AtomicWait, Opcode::MemoryAtomicWait32}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 539 "src/lexer-keywords.txt" + {"memory.atomic.wait64", TokenType::AtomicWait, Opcode::MemoryAtomicWait64}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, +#line 397 "src/lexer-keywords.txt" + {"i64.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I64AtomicRmwSub}, +#line 260 "src/lexer-keywords.txt" + {"i32.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I32AtomicRmwSub}, +#line 495 "src/lexer-keywords.txt" + {"i8x16.bitmask", TokenType::Unary, Opcode::I8X16Bitmask}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 540 "src/lexer-keywords.txt" + {"memory.copy", TokenType::MemoryCopy, Opcode::MemoryCopy}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, +#line 514 "src/lexer-keywords.txt" + {"i8x16.popcnt", TokenType::Unary, Opcode::I8X16Popcnt}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, +#line 27 "src/lexer-keywords.txt" + {"assert_unlinkable", TokenType::AssertUnlinkable}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 608 "src/lexer-keywords.txt" + {"i8x16.shuffle", TokenType::SimdShuffleOp, Opcode::I8X16Shuffle}, + {""}, {""}, {""}, {""}, +#line 434 "src/lexer-keywords.txt" + {"i64.popcnt", TokenType::Unary, Opcode::I64Popcnt}, +#line 291 "src/lexer-keywords.txt" + {"i32.popcnt", TokenType::Unary, Opcode::I32Popcnt}, + {""}, {""}, {""}, {""}, +#line 175 "src/lexer-keywords.txt" + {"f64x2.convert_low_i32x4_u", TokenType::Unary, Opcode::F64X2ConvertLowI32X4U}, + {""}, +#line 174 "src/lexer-keywords.txt" + {"f64x2.convert_low_i32x4_s", TokenType::Unary, Opcode::F64X2ConvertLowI32X4S}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, +#line 227 "src/lexer-keywords.txt" + {"i16x8.extadd_pairwise_i8x16_u", TokenType::Unary, Opcode::I16X8ExtaddPairwiseI8X16U}, + {""}, +#line 226 "src/lexer-keywords.txt" + {"i16x8.extadd_pairwise_i8x16_s", TokenType::Unary, Opcode::I16X8ExtaddPairwiseI8X16S}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 537 "src/lexer-keywords.txt" + {"memory.atomic.notify", TokenType::AtomicNotify, Opcode::MemoryAtomicNotify}, + {""}, {""}, +#line 26 "src/lexer-keywords.txt" + {"assert_trap", TokenType::AssertTrap}, +#line 78 "src/lexer-keywords.txt" + {"f32.reinterpret_i32", TokenType::Convert, Opcode::F32ReinterpretI32}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 139 "src/lexer-keywords.txt" + {"f64.promote_f32", TokenType::Convert, Opcode::F64PromoteF32}, + {""}, {""}, {""}, {""}, +#line 192 "src/lexer-keywords.txt" + {"i16x8.dot_i8x16_i7x16_s", TokenType::Binary, Opcode::I16X8DotI8X16I7X16S}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 150 "src/lexer-keywords.txt" + {"f64x2.eq", TokenType::Compare, Opcode::F64X2Eq}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 462 "src/lexer-keywords.txt" + {"i64x2.eq", TokenType::Binary, Opcode::I64X2Eq}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 234 "src/lexer-keywords.txt" + {"i16x8.extend_high_i8x16_u", TokenType::Unary, Opcode::I16X8ExtendHighI8X16U}, + {""}, +#line 233 "src/lexer-keywords.txt" + {"i16x8.extend_high_i8x16_s", TokenType::Unary, Opcode::I16X8ExtendHighI8X16S}, + {""}, {""}, +#line 231 "src/lexer-keywords.txt" + {"i16x8.extmul_high_i8x16_u", TokenType::Binary, Opcode::I16X8ExtmulHighI8X16U}, +#line 21 "src/lexer-keywords.txt" + {"assert_exception", TokenType::AssertException}, +#line 229 "src/lexer-keywords.txt" + {"i16x8.extmul_high_i8x16_s", TokenType::Binary, Opcode::I16X8ExtmulHighI8X16S}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, +#line 435 "src/lexer-keywords.txt" + {"i64.reinterpret_f64", TokenType::Convert, Opcode::I64ReinterpretF64}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 193 "src/lexer-keywords.txt" + {"i16x8.eq", TokenType::Compare, Opcode::I16X8Eq}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 46 "src/lexer-keywords.txt" + {"elem.drop", TokenType::ElemDrop, Opcode::ElemDrop}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 214 "src/lexer-keywords.txt" + {"i16x8.q15mulr_sat_s", TokenType::Binary, Opcode::I16X8Q15mulrSatS}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 292 "src/lexer-keywords.txt" + {"i32.reinterpret_f32", TokenType::Convert, Opcode::I32ReinterpretF32}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, +#line 28 "src/lexer-keywords.txt" + {"atomic.fence", TokenType::AtomicFence, Opcode::AtomicFence}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, +#line 496 "src/lexer-keywords.txt" + {"i8x16.eq", TokenType::Compare, Opcode::I8X16Eq}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, +#line 512 "src/lexer-keywords.txt" + {"i8x16.narrow_i16x8_u", TokenType::Binary, Opcode::I8X16NarrowI16X8U}, + {""}, +#line 511 "src/lexer-keywords.txt" + {"i8x16.narrow_i16x8_s", TokenType::Binary, Opcode::I8X16NarrowI16X8S}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, +#line 176 "src/lexer-keywords.txt" + {"f64x2.promote_low_f32x4", TokenType::Unary, Opcode::F64X2PromoteLowF32X4} + }; + + if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) + { + unsigned int key = hash (str, len); + + if (key <= MAX_HASH_VALUE) + { + const char *s = wordlist[key].name; + + if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0') + return &wordlist[key]; + } + } + return 0; +} diff --git a/third_party/wasm2c/src/prebuilt/wasm2c_header_bottom.cc b/third_party/wasm2c/src/prebuilt/wasm2c_header_bottom.cc new file mode 100644 index 0000000000..7db8468ff7 --- /dev/null +++ b/third_party/wasm2c/src/prebuilt/wasm2c_header_bottom.cc @@ -0,0 +1,7 @@ +const char* s_header_bottom = R"w2c_template(#ifdef __cplusplus +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template(#endif +)w2c_template" +; diff --git a/third_party/wasm2c/src/prebuilt/wasm2c_header_top.cc b/third_party/wasm2c/src/prebuilt/wasm2c_header_top.cc new file mode 100644 index 0000000000..d36aaf0c0f --- /dev/null +++ b/third_party/wasm2c/src/prebuilt/wasm2c_header_top.cc @@ -0,0 +1,64 @@ +const char* s_header_top = R"w2c_template(#include <stdint.h> +)w2c_template" +R"w2c_template( +#include "wasm-rt.h" +)w2c_template" +R"w2c_template( +#if defined(WASM_RT_ENABLE_EXCEPTION_HANDLING) +)w2c_template" +R"w2c_template(#include "wasm-rt-exceptions.h" +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( +#if defined(WASM_RT_ENABLE_SIMD) +)w2c_template" +R"w2c_template(#include "simde/wasm/simd128.h" +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( +/* TODO(binji): only use stdint.h types in header */ +)w2c_template" +R"w2c_template(#ifndef WASM_RT_CORE_TYPES_DEFINED +)w2c_template" +R"w2c_template(#define WASM_RT_CORE_TYPES_DEFINED +)w2c_template" +R"w2c_template(typedef uint8_t u8; +)w2c_template" +R"w2c_template(typedef int8_t s8; +)w2c_template" +R"w2c_template(typedef uint16_t u16; +)w2c_template" +R"w2c_template(typedef int16_t s16; +)w2c_template" +R"w2c_template(typedef uint32_t u32; +)w2c_template" +R"w2c_template(typedef int32_t s32; +)w2c_template" +R"w2c_template(typedef uint64_t u64; +)w2c_template" +R"w2c_template(typedef int64_t s64; +)w2c_template" +R"w2c_template(typedef float f32; +)w2c_template" +R"w2c_template(typedef double f64; +)w2c_template" +R"w2c_template( +#if defined(WASM_RT_ENABLE_SIMD) +)w2c_template" +R"w2c_template(typedef simde_v128_t v128; +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( +#endif +)w2c_template" +R"w2c_template( +#ifdef __cplusplus +)w2c_template" +R"w2c_template(extern "C" { +)w2c_template" +R"w2c_template(#endif +)w2c_template" +; diff --git a/third_party/wasm2c/src/prebuilt/wasm2c_source_declarations.cc b/third_party/wasm2c/src/prebuilt/wasm2c_source_declarations.cc new file mode 100644 index 0000000000..2e9ebe5d99 --- /dev/null +++ b/third_party/wasm2c/src/prebuilt/wasm2c_source_declarations.cc @@ -0,0 +1,1339 @@ +const char* s_source_declarations = R"w2c_template( +#define TRAP(x) (wasm_rt_trap(WASM_RT_TRAP_##x), 0) +)w2c_template" +R"w2c_template( +#if WASM_RT_USE_STACK_DEPTH_COUNT +)w2c_template" +R"w2c_template(#define FUNC_PROLOGUE \ +)w2c_template" +R"w2c_template( if (++wasm_rt_call_stack_depth > WASM_RT_MAX_CALL_STACK_DEPTH) \ +)w2c_template" +R"w2c_template( TRAP(EXHAUSTION); +)w2c_template" +R"w2c_template( +#define FUNC_EPILOGUE --wasm_rt_call_stack_depth +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template(#define FUNC_PROLOGUE +)w2c_template" +R"w2c_template( +#define FUNC_EPILOGUE +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( +#define UNREACHABLE TRAP(UNREACHABLE) +)w2c_template" +R"w2c_template( +static inline bool func_types_eq(const wasm_rt_func_type_t a, +)w2c_template" +R"w2c_template( const wasm_rt_func_type_t b) { +)w2c_template" +R"w2c_template( return (a == b) || LIKELY(a && b && !memcmp(a, b, 32)); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +#define CALL_INDIRECT(table, t, ft, x, ...) \ +)w2c_template" +R"w2c_template( (LIKELY((x) < table.size && table.data[x].func && \ +)w2c_template" +R"w2c_template( func_types_eq(ft, table.data[x].func_type)) || \ +)w2c_template" +R"w2c_template( TRAP(CALL_INDIRECT), \ +)w2c_template" +R"w2c_template( ((t)table.data[x].func)(__VA_ARGS__)) +)w2c_template" +R"w2c_template( +#ifdef SUPPORT_MEMORY64 +)w2c_template" +R"w2c_template(#define RANGE_CHECK(mem, offset, len) \ +)w2c_template" +R"w2c_template( do { \ +)w2c_template" +R"w2c_template( uint64_t res; \ +)w2c_template" +R"w2c_template( if (__builtin_add_overflow(offset, len, &res)) \ +)w2c_template" +R"w2c_template( TRAP(OOB); \ +)w2c_template" +R"w2c_template( if (UNLIKELY(res > mem->size)) \ +)w2c_template" +R"w2c_template( TRAP(OOB); \ +)w2c_template" +R"w2c_template( } while (0); +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template(#define RANGE_CHECK(mem, offset, len) \ +)w2c_template" +R"w2c_template( if (UNLIKELY(offset + (uint64_t)len > mem->size)) \ +)w2c_template" +R"w2c_template( TRAP(OOB); +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( +#if WASM_RT_MEMCHECK_GUARD_PAGES +)w2c_template" +R"w2c_template(#define MEMCHECK(mem, a, t) +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template(#define MEMCHECK(mem, a, t) RANGE_CHECK(mem, a, sizeof(t)) +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( +#ifdef __GNUC__ +)w2c_template" +R"w2c_template(#define wasm_asm __asm__ +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template(#define wasm_asm(X) +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( +#if WABT_BIG_ENDIAN +)w2c_template" +R"w2c_template(static inline void load_data(void* dest, const void* src, size_t n) { +)w2c_template" +R"w2c_template( if (!n) { +)w2c_template" +R"w2c_template( return; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( size_t i = 0; +)w2c_template" +R"w2c_template( u8* dest_chars = dest; +)w2c_template" +R"w2c_template( memcpy(dest, src, n); +)w2c_template" +R"w2c_template( for (i = 0; i < (n >> 1); i++) { +)w2c_template" +R"w2c_template( u8 cursor = dest_chars[i]; +)w2c_template" +R"w2c_template( dest_chars[i] = dest_chars[n - i - 1]; +)w2c_template" +R"w2c_template( dest_chars[n - i - 1] = cursor; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template(#define LOAD_DATA(m, o, i, s) \ +)w2c_template" +R"w2c_template( do { \ +)w2c_template" +R"w2c_template( RANGE_CHECK((&m), m.size - o - s, s); \ +)w2c_template" +R"w2c_template( load_data(&(m.data[m.size - o - s]), i, s); \ +)w2c_template" +R"w2c_template( } while (0) +)w2c_template" +R"w2c_template(#define DEFINE_LOAD(name, t1, t2, t3) \ +)w2c_template" +R"w2c_template( static inline t3 name(wasm_rt_memory_t* mem, u64 addr) { \ +)w2c_template" +R"w2c_template( MEMCHECK(mem, addr, t1); \ +)w2c_template" +R"w2c_template( t1 result; \ +)w2c_template" +R"w2c_template( wasm_rt_memcpy(&result, &mem->data[mem->size - addr - sizeof(t1)], \ +)w2c_template" +R"w2c_template( sizeof(t1)); \ +)w2c_template" +R"w2c_template( wasm_asm("" ::"r"(result)); \ +)w2c_template" +R"w2c_template( return (t3)(t2)result; \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +#define DEFINE_STORE(name, t1, t2) \ +)w2c_template" +R"w2c_template( static inline void name(wasm_rt_memory_t* mem, u64 addr, t2 value) { \ +)w2c_template" +R"w2c_template( MEMCHECK(mem, addr, t1); \ +)w2c_template" +R"w2c_template( t1 wrapped = (t1)value; \ +)w2c_template" +R"w2c_template( wasm_rt_memcpy(&mem->data[mem->size - addr - sizeof(t1)], &wrapped, \ +)w2c_template" +R"w2c_template( sizeof(t1)); \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template(static inline void load_data(void* dest, const void* src, size_t n) { +)w2c_template" +R"w2c_template( if (!n) { +)w2c_template" +R"w2c_template( return; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( memcpy(dest, src, n); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template(#define LOAD_DATA(m, o, i, s) \ +)w2c_template" +R"w2c_template( do { \ +)w2c_template" +R"w2c_template( RANGE_CHECK((&m), o, s); \ +)w2c_template" +R"w2c_template( load_data(&(m.data[o]), i, s); \ +)w2c_template" +R"w2c_template( } while (0) +)w2c_template" +R"w2c_template(#define DEFINE_LOAD(name, t1, t2, t3) \ +)w2c_template" +R"w2c_template( static inline t3 name(wasm_rt_memory_t* mem, u64 addr) { \ +)w2c_template" +R"w2c_template( MEMCHECK(mem, addr, t1); \ +)w2c_template" +R"w2c_template( t1 result; \ +)w2c_template" +R"w2c_template( wasm_rt_memcpy(&result, &mem->data[addr], sizeof(t1)); \ +)w2c_template" +R"w2c_template( wasm_asm("" ::"r"(result)); \ +)w2c_template" +R"w2c_template( return (t3)(t2)result; \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +#define DEFINE_STORE(name, t1, t2) \ +)w2c_template" +R"w2c_template( static inline void name(wasm_rt_memory_t* mem, u64 addr, t2 value) { \ +)w2c_template" +R"w2c_template( MEMCHECK(mem, addr, t1); \ +)w2c_template" +R"w2c_template( t1 wrapped = (t1)value; \ +)w2c_template" +R"w2c_template( wasm_rt_memcpy(&mem->data[addr], &wrapped, sizeof(t1)); \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( +DEFINE_LOAD(i32_load, u32, u32, u32) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i64_load, u64, u64, u64) +)w2c_template" +R"w2c_template(DEFINE_LOAD(f32_load, f32, f32, f32) +)w2c_template" +R"w2c_template(DEFINE_LOAD(f64_load, f64, f64, f64) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i32_load8_s, s8, s32, u32) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i64_load8_s, s8, s64, u64) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i32_load8_u, u8, u32, u32) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i64_load8_u, u8, u64, u64) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i32_load16_s, s16, s32, u32) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i64_load16_s, s16, s64, u64) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i32_load16_u, u16, u32, u32) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i64_load16_u, u16, u64, u64) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i64_load32_s, s32, s64, u64) +)w2c_template" +R"w2c_template(DEFINE_LOAD(i64_load32_u, u32, u64, u64) +)w2c_template" +R"w2c_template(DEFINE_STORE(i32_store, u32, u32) +)w2c_template" +R"w2c_template(DEFINE_STORE(i64_store, u64, u64) +)w2c_template" +R"w2c_template(DEFINE_STORE(f32_store, f32, f32) +)w2c_template" +R"w2c_template(DEFINE_STORE(f64_store, f64, f64) +)w2c_template" +R"w2c_template(DEFINE_STORE(i32_store8, u8, u32) +)w2c_template" +R"w2c_template(DEFINE_STORE(i32_store16, u16, u32) +)w2c_template" +R"w2c_template(DEFINE_STORE(i64_store8, u8, u64) +)w2c_template" +R"w2c_template(DEFINE_STORE(i64_store16, u16, u64) +)w2c_template" +R"w2c_template(DEFINE_STORE(i64_store32, u32, u64) +)w2c_template" +R"w2c_template( +#if defined(WASM_RT_ENABLE_SIMD) +)w2c_template" +R"w2c_template( +#ifdef __x86_64__ +)w2c_template" +R"w2c_template(#define SIMD_FORCE_READ(var) wasm_asm("" ::"x"(var)); +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template(#define SIMD_FORCE_READ(var) +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template(// TODO: equivalent constraint for ARM and other architectures +)w2c_template" +R"w2c_template( +#define DEFINE_SIMD_LOAD_FUNC(name, func, t) \ +)w2c_template" +R"w2c_template( static inline v128 name(wasm_rt_memory_t* mem, u64 addr) { \ +)w2c_template" +R"w2c_template( MEMCHECK(mem, addr, t); \ +)w2c_template" +R"w2c_template( v128 result = func((v128*)&mem->data[addr]); \ +)w2c_template" +R"w2c_template( SIMD_FORCE_READ(result); \ +)w2c_template" +R"w2c_template( return result; \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +#define DEFINE_SIMD_LOAD_LANE(name, func, t, lane) \ +)w2c_template" +R"w2c_template( static inline v128 name(wasm_rt_memory_t* mem, u64 addr, v128 vec) { \ +)w2c_template" +R"w2c_template( MEMCHECK(mem, addr, t); \ +)w2c_template" +R"w2c_template( v128 result = func((v128*)&mem->data[addr], vec, lane); \ +)w2c_template" +R"w2c_template( SIMD_FORCE_READ(result); \ +)w2c_template" +R"w2c_template( return result; \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +#define DEFINE_SIMD_STORE(name, t) \ +)w2c_template" +R"w2c_template( static inline void name(wasm_rt_memory_t* mem, u64 addr, v128 value) { \ +)w2c_template" +R"w2c_template( MEMCHECK(mem, addr, t); \ +)w2c_template" +R"w2c_template( simde_wasm_v128_store((v128*)&mem->data[addr], value); \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +#define DEFINE_SIMD_STORE_LANE(name, func, t, lane) \ +)w2c_template" +R"w2c_template( static inline void name(wasm_rt_memory_t* mem, u64 addr, v128 value) { \ +)w2c_template" +R"w2c_template( MEMCHECK(mem, addr, t); \ +)w2c_template" +R"w2c_template( func((v128*)&mem->data[addr], value, lane); \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +// clang-format off +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(v128_load, simde_wasm_v128_load, v128) +)w2c_template" +R"w2c_template( +DEFINE_SIMD_LOAD_FUNC(v128_load8_splat, simde_wasm_v128_load8_splat, u8) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(v128_load16_splat, simde_wasm_v128_load16_splat, u16) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(v128_load32_splat, simde_wasm_v128_load32_splat, u32) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(v128_load64_splat, simde_wasm_v128_load64_splat, u64) +)w2c_template" +R"w2c_template( +DEFINE_SIMD_LOAD_FUNC(i16x8_load8x8, simde_wasm_i16x8_load8x8, u64) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(u16x8_load8x8, simde_wasm_u16x8_load8x8, u64) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(i32x4_load16x4, simde_wasm_i32x4_load16x4, u64) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(u32x4_load16x4, simde_wasm_u32x4_load16x4, u64) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(i64x2_load32x2, simde_wasm_i64x2_load32x2, u64) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(u64x2_load32x2, simde_wasm_u64x2_load32x2, u64) +)w2c_template" +R"w2c_template( +DEFINE_SIMD_LOAD_FUNC(v128_load32_zero, simde_wasm_v128_load32_zero, u32) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_FUNC(v128_load64_zero, simde_wasm_v128_load64_zero, u64) +)w2c_template" +R"w2c_template( +DEFINE_SIMD_LOAD_LANE(v128_load8_lane0, simde_wasm_v128_load8_lane, u8, 0) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane1, simde_wasm_v128_load8_lane, u8, 1) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane2, simde_wasm_v128_load8_lane, u8, 2) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane3, simde_wasm_v128_load8_lane, u8, 3) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane4, simde_wasm_v128_load8_lane, u8, 4) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane5, simde_wasm_v128_load8_lane, u8, 5) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane6, simde_wasm_v128_load8_lane, u8, 6) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane7, simde_wasm_v128_load8_lane, u8, 7) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane8, simde_wasm_v128_load8_lane, u8, 8) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane9, simde_wasm_v128_load8_lane, u8, 9) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane10, simde_wasm_v128_load8_lane, u8, 10) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane11, simde_wasm_v128_load8_lane, u8, 11) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane12, simde_wasm_v128_load8_lane, u8, 12) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane13, simde_wasm_v128_load8_lane, u8, 13) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane14, simde_wasm_v128_load8_lane, u8, 14) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load8_lane15, simde_wasm_v128_load8_lane, u8, 15) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load16_lane0, simde_wasm_v128_load16_lane, u16, 0) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load16_lane1, simde_wasm_v128_load16_lane, u16, 1) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load16_lane2, simde_wasm_v128_load16_lane, u16, 2) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load16_lane3, simde_wasm_v128_load16_lane, u16, 3) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load16_lane4, simde_wasm_v128_load16_lane, u16, 4) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load16_lane5, simde_wasm_v128_load16_lane, u16, 5) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load16_lane6, simde_wasm_v128_load16_lane, u16, 6) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load16_lane7, simde_wasm_v128_load16_lane, u16, 7) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load32_lane0, simde_wasm_v128_load32_lane, u32, 0) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load32_lane1, simde_wasm_v128_load32_lane, u32, 1) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load32_lane2, simde_wasm_v128_load32_lane, u32, 2) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load32_lane3, simde_wasm_v128_load32_lane, u32, 3) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load64_lane0, simde_wasm_v128_load64_lane, u64, 0) +)w2c_template" +R"w2c_template(DEFINE_SIMD_LOAD_LANE(v128_load64_lane1, simde_wasm_v128_load64_lane, u64, 1) +)w2c_template" +R"w2c_template( +DEFINE_SIMD_STORE(v128_store, v128) +)w2c_template" +R"w2c_template( +DEFINE_SIMD_STORE_LANE(v128_store8_lane0, simde_wasm_v128_store8_lane, u8, 0) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane1, simde_wasm_v128_store8_lane, u8, 1) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane2, simde_wasm_v128_store8_lane, u8, 2) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane3, simde_wasm_v128_store8_lane, u8, 3) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane4, simde_wasm_v128_store8_lane, u8, 4) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane5, simde_wasm_v128_store8_lane, u8, 5) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane6, simde_wasm_v128_store8_lane, u8, 6) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane7, simde_wasm_v128_store8_lane, u8, 7) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane8, simde_wasm_v128_store8_lane, u8, 8) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane9, simde_wasm_v128_store8_lane, u8, 9) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane10, simde_wasm_v128_store8_lane, u8, 10) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane11, simde_wasm_v128_store8_lane, u8, 11) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane12, simde_wasm_v128_store8_lane, u8, 12) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane13, simde_wasm_v128_store8_lane, u8, 13) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane14, simde_wasm_v128_store8_lane, u8, 14) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store8_lane15, simde_wasm_v128_store8_lane, u8, 15) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store16_lane0, simde_wasm_v128_store16_lane, u16, 0) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store16_lane1, simde_wasm_v128_store16_lane, u16, 1) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store16_lane2, simde_wasm_v128_store16_lane, u16, 2) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store16_lane3, simde_wasm_v128_store16_lane, u16, 3) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store16_lane4, simde_wasm_v128_store16_lane, u16, 4) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store16_lane5, simde_wasm_v128_store16_lane, u16, 5) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store16_lane6, simde_wasm_v128_store16_lane, u16, 6) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store16_lane7, simde_wasm_v128_store16_lane, u16, 7) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store32_lane0, simde_wasm_v128_store32_lane, u32, 0) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store32_lane1, simde_wasm_v128_store32_lane, u32, 1) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store32_lane2, simde_wasm_v128_store32_lane, u32, 2) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store32_lane3, simde_wasm_v128_store32_lane, u32, 3) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store64_lane0, simde_wasm_v128_store64_lane, u64, 0) +)w2c_template" +R"w2c_template(DEFINE_SIMD_STORE_LANE(v128_store64_lane1, simde_wasm_v128_store64_lane, u64, 1) +)w2c_template" +R"w2c_template(// clang-format on +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( +#if defined(_MSC_VER) +)w2c_template" +R"w2c_template( +// Adapted from +)w2c_template" +R"w2c_template(// https://github.com/nemequ/portable-snippets/blob/master/builtin/builtin.h +)w2c_template" +R"w2c_template( +static inline int I64_CLZ(unsigned long long v) { +)w2c_template" +R"w2c_template( unsigned long r = 0; +)w2c_template" +R"w2c_template(#if defined(_M_AMD64) || defined(_M_ARM) +)w2c_template" +R"w2c_template( if (_BitScanReverse64(&r, v)) { +)w2c_template" +R"w2c_template( return 63 - r; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template( if (_BitScanReverse(&r, (unsigned long)(v >> 32))) { +)w2c_template" +R"w2c_template( return 31 - r; +)w2c_template" +R"w2c_template( } else if (_BitScanReverse(&r, (unsigned long)v)) { +)w2c_template" +R"w2c_template( return 63 - r; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template( return 64; +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static inline int I32_CLZ(unsigned long v) { +)w2c_template" +R"w2c_template( unsigned long r = 0; +)w2c_template" +R"w2c_template( if (_BitScanReverse(&r, v)) { +)w2c_template" +R"w2c_template( return 31 - r; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return 32; +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static inline int I64_CTZ(unsigned long long v) { +)w2c_template" +R"w2c_template( if (!v) { +)w2c_template" +R"w2c_template( return 64; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( unsigned long r = 0; +)w2c_template" +R"w2c_template(#if defined(_M_AMD64) || defined(_M_ARM) +)w2c_template" +R"w2c_template( _BitScanForward64(&r, v); +)w2c_template" +R"w2c_template( return (int)r; +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template( if (_BitScanForward(&r, (unsigned int)(v))) { +)w2c_template" +R"w2c_template( return (int)(r); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( + _BitScanForward(&r, (unsigned int)(v >> 32)); +)w2c_template" +R"w2c_template( return (int)(r + 32); +)w2c_template" +R"w2c_template(#endif +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static inline int I32_CTZ(unsigned long v) { +)w2c_template" +R"w2c_template( if (!v) { +)w2c_template" +R"w2c_template( return 32; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( unsigned long r = 0; +)w2c_template" +R"w2c_template( _BitScanForward(&r, v); +)w2c_template" +R"w2c_template( return (int)r; +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +#define POPCOUNT_DEFINE_PORTABLE(f_n, T) \ +)w2c_template" +R"w2c_template( static inline u32 f_n(T x) { \ +)w2c_template" +R"w2c_template( x = x - ((x >> 1) & (T) ~(T)0 / 3); \ +)w2c_template" +R"w2c_template( x = (x & (T) ~(T)0 / 15 * 3) + ((x >> 2) & (T) ~(T)0 / 15 * 3); \ +)w2c_template" +R"w2c_template( x = (x + (x >> 4)) & (T) ~(T)0 / 255 * 15; \ +)w2c_template" +R"w2c_template( return (T)(x * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8; \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +POPCOUNT_DEFINE_PORTABLE(I32_POPCNT, u32) +)w2c_template" +R"w2c_template(POPCOUNT_DEFINE_PORTABLE(I64_POPCNT, u64) +)w2c_template" +R"w2c_template( +#undef POPCOUNT_DEFINE_PORTABLE +)w2c_template" +R"w2c_template( +#else +)w2c_template" +R"w2c_template( +#define I32_CLZ(x) ((x) ? __builtin_clz(x) : 32) +)w2c_template" +R"w2c_template(#define I64_CLZ(x) ((x) ? __builtin_clzll(x) : 64) +)w2c_template" +R"w2c_template(#define I32_CTZ(x) ((x) ? __builtin_ctz(x) : 32) +)w2c_template" +R"w2c_template(#define I64_CTZ(x) ((x) ? __builtin_ctzll(x) : 64) +)w2c_template" +R"w2c_template(#define I32_POPCNT(x) (__builtin_popcount(x)) +)w2c_template" +R"w2c_template(#define I64_POPCNT(x) (__builtin_popcountll(x)) +)w2c_template" +R"w2c_template( +#endif +)w2c_template" +R"w2c_template( +#define DIV_S(ut, min, x, y) \ +)w2c_template" +R"w2c_template( ((UNLIKELY((y) == 0)) \ +)w2c_template" +R"w2c_template( ? TRAP(DIV_BY_ZERO) \ +)w2c_template" +R"w2c_template( : (UNLIKELY((x) == min && (y) == -1)) ? TRAP(INT_OVERFLOW) \ +)w2c_template" +R"w2c_template( : (ut)((x) / (y))) +)w2c_template" +R"w2c_template( +#define REM_S(ut, min, x, y) \ +)w2c_template" +R"w2c_template( ((UNLIKELY((y) == 0)) \ +)w2c_template" +R"w2c_template( ? TRAP(DIV_BY_ZERO) \ +)w2c_template" +R"w2c_template( : (UNLIKELY((x) == min && (y) == -1)) ? 0 : (ut)((x) % (y))) +)w2c_template" +R"w2c_template( +#define I32_DIV_S(x, y) DIV_S(u32, INT32_MIN, (s32)x, (s32)y) +)w2c_template" +R"w2c_template(#define I64_DIV_S(x, y) DIV_S(u64, INT64_MIN, (s64)x, (s64)y) +)w2c_template" +R"w2c_template(#define I32_REM_S(x, y) REM_S(u32, INT32_MIN, (s32)x, (s32)y) +)w2c_template" +R"w2c_template(#define I64_REM_S(x, y) REM_S(u64, INT64_MIN, (s64)x, (s64)y) +)w2c_template" +R"w2c_template( +#define DIVREM_U(op, x, y) \ +)w2c_template" +R"w2c_template( ((UNLIKELY((y) == 0)) ? TRAP(DIV_BY_ZERO) : ((x)op(y))) +)w2c_template" +R"w2c_template( +#define DIV_U(x, y) DIVREM_U(/, x, y) +)w2c_template" +R"w2c_template(#define REM_U(x, y) DIVREM_U(%, x, y) +)w2c_template" +R"w2c_template( +#define ROTL(x, y, mask) \ +)w2c_template" +R"w2c_template( (((x) << ((y) & (mask))) | ((x) >> (((mask) - (y) + 1) & (mask)))) +)w2c_template" +R"w2c_template(#define ROTR(x, y, mask) \ +)w2c_template" +R"w2c_template( (((x) >> ((y) & (mask))) | ((x) << (((mask) - (y) + 1) & (mask)))) +)w2c_template" +R"w2c_template( +#define I32_ROTL(x, y) ROTL(x, y, 31) +)w2c_template" +R"w2c_template(#define I64_ROTL(x, y) ROTL(x, y, 63) +)w2c_template" +R"w2c_template(#define I32_ROTR(x, y) ROTR(x, y, 31) +)w2c_template" +R"w2c_template(#define I64_ROTR(x, y) ROTR(x, y, 63) +)w2c_template" +R"w2c_template( +#define FMIN(x, y) \ +)w2c_template" +R"w2c_template( ((UNLIKELY((x) != (x))) \ +)w2c_template" +R"w2c_template( ? NAN \ +)w2c_template" +R"w2c_template( : (UNLIKELY((y) != (y))) \ +)w2c_template" +R"w2c_template( ? NAN \ +)w2c_template" +R"w2c_template( : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? x : y) \ +)w2c_template" +R"w2c_template( : (x < y) ? x : y) +)w2c_template" +R"w2c_template( +#define FMAX(x, y) \ +)w2c_template" +R"w2c_template( ((UNLIKELY((x) != (x))) \ +)w2c_template" +R"w2c_template( ? NAN \ +)w2c_template" +R"w2c_template( : (UNLIKELY((y) != (y))) \ +)w2c_template" +R"w2c_template( ? NAN \ +)w2c_template" +R"w2c_template( : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? y : x) \ +)w2c_template" +R"w2c_template( : (x > y) ? x : y) +)w2c_template" +R"w2c_template( +#define TRUNC_S(ut, st, ft, min, minop, max, x) \ +)w2c_template" +R"w2c_template( ((UNLIKELY((x) != (x))) \ +)w2c_template" +R"w2c_template( ? TRAP(INVALID_CONVERSION) \ +)w2c_template" +R"w2c_template( : (UNLIKELY(!((x)minop(min) && (x) < (max)))) ? TRAP(INT_OVERFLOW) \ +)w2c_template" +R"w2c_template( : (ut)(st)(x)) +)w2c_template" +R"w2c_template( +#define I32_TRUNC_S_F32(x) \ +)w2c_template" +R"w2c_template( TRUNC_S(u32, s32, f32, (f32)INT32_MIN, >=, 2147483648.f, x) +)w2c_template" +R"w2c_template(#define I64_TRUNC_S_F32(x) \ +)w2c_template" +R"w2c_template( TRUNC_S(u64, s64, f32, (f32)INT64_MIN, >=, (f32)INT64_MAX, x) +)w2c_template" +R"w2c_template(#define I32_TRUNC_S_F64(x) \ +)w2c_template" +R"w2c_template( TRUNC_S(u32, s32, f64, -2147483649., >, 2147483648., x) +)w2c_template" +R"w2c_template(#define I64_TRUNC_S_F64(x) \ +)w2c_template" +R"w2c_template( TRUNC_S(u64, s64, f64, (f64)INT64_MIN, >=, (f64)INT64_MAX, x) +)w2c_template" +R"w2c_template( +#define TRUNC_U(ut, ft, max, x) \ +)w2c_template" +R"w2c_template( ((UNLIKELY((x) != (x))) \ +)w2c_template" +R"w2c_template( ? TRAP(INVALID_CONVERSION) \ +)w2c_template" +R"w2c_template( : (UNLIKELY(!((x) > (ft)-1 && (x) < (max)))) ? TRAP(INT_OVERFLOW) \ +)w2c_template" +R"w2c_template( : (ut)(x)) +)w2c_template" +R"w2c_template( +#define I32_TRUNC_U_F32(x) TRUNC_U(u32, f32, 4294967296.f, x) +)w2c_template" +R"w2c_template(#define I64_TRUNC_U_F32(x) TRUNC_U(u64, f32, (f32)UINT64_MAX, x) +)w2c_template" +R"w2c_template(#define I32_TRUNC_U_F64(x) TRUNC_U(u32, f64, 4294967296., x) +)w2c_template" +R"w2c_template(#define I64_TRUNC_U_F64(x) TRUNC_U(u64, f64, (f64)UINT64_MAX, x) +)w2c_template" +R"w2c_template( +#define TRUNC_SAT_S(ut, st, ft, min, smin, minop, max, smax, x) \ +)w2c_template" +R"w2c_template( ((UNLIKELY((x) != (x))) \ +)w2c_template" +R"w2c_template( ? 0 \ +)w2c_template" +R"w2c_template( : (UNLIKELY(!((x)minop(min)))) \ +)w2c_template" +R"w2c_template( ? smin \ +)w2c_template" +R"w2c_template( : (UNLIKELY(!((x) < (max)))) ? smax : (ut)(st)(x)) +)w2c_template" +R"w2c_template( +#define I32_TRUNC_SAT_S_F32(x) \ +)w2c_template" +R"w2c_template( TRUNC_SAT_S(u32, s32, f32, (f32)INT32_MIN, INT32_MIN, >=, 2147483648.f, \ +)w2c_template" +R"w2c_template( INT32_MAX, x) +)w2c_template" +R"w2c_template(#define I64_TRUNC_SAT_S_F32(x) \ +)w2c_template" +R"w2c_template( TRUNC_SAT_S(u64, s64, f32, (f32)INT64_MIN, INT64_MIN, >=, (f32)INT64_MAX, \ +)w2c_template" +R"w2c_template( INT64_MAX, x) +)w2c_template" +R"w2c_template(#define I32_TRUNC_SAT_S_F64(x) \ +)w2c_template" +R"w2c_template( TRUNC_SAT_S(u32, s32, f64, -2147483649., INT32_MIN, >, 2147483648., \ +)w2c_template" +R"w2c_template( INT32_MAX, x) +)w2c_template" +R"w2c_template(#define I64_TRUNC_SAT_S_F64(x) \ +)w2c_template" +R"w2c_template( TRUNC_SAT_S(u64, s64, f64, (f64)INT64_MIN, INT64_MIN, >=, (f64)INT64_MAX, \ +)w2c_template" +R"w2c_template( INT64_MAX, x) +)w2c_template" +R"w2c_template( +#define TRUNC_SAT_U(ut, ft, max, smax, x) \ +)w2c_template" +R"w2c_template( ((UNLIKELY((x) != (x))) ? 0 \ +)w2c_template" +R"w2c_template( : (UNLIKELY(!((x) > (ft)-1))) \ +)w2c_template" +R"w2c_template( ? 0 \ +)w2c_template" +R"w2c_template( : (UNLIKELY(!((x) < (max)))) ? smax : (ut)(x)) +)w2c_template" +R"w2c_template( +#define I32_TRUNC_SAT_U_F32(x) \ +)w2c_template" +R"w2c_template( TRUNC_SAT_U(u32, f32, 4294967296.f, UINT32_MAX, x) +)w2c_template" +R"w2c_template(#define I64_TRUNC_SAT_U_F32(x) \ +)w2c_template" +R"w2c_template( TRUNC_SAT_U(u64, f32, (f32)UINT64_MAX, UINT64_MAX, x) +)w2c_template" +R"w2c_template(#define I32_TRUNC_SAT_U_F64(x) TRUNC_SAT_U(u32, f64, 4294967296., UINT32_MAX, x) +)w2c_template" +R"w2c_template(#define I64_TRUNC_SAT_U_F64(x) \ +)w2c_template" +R"w2c_template( TRUNC_SAT_U(u64, f64, (f64)UINT64_MAX, UINT64_MAX, x) +)w2c_template" +R"w2c_template( +#define DEFINE_REINTERPRET(name, t1, t2) \ +)w2c_template" +R"w2c_template( static inline t2 name(t1 x) { \ +)w2c_template" +R"w2c_template( t2 result; \ +)w2c_template" +R"w2c_template( memcpy(&result, &x, sizeof(result)); \ +)w2c_template" +R"w2c_template( return result; \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +DEFINE_REINTERPRET(f32_reinterpret_i32, u32, f32) +)w2c_template" +R"w2c_template(DEFINE_REINTERPRET(i32_reinterpret_f32, f32, u32) +)w2c_template" +R"w2c_template(DEFINE_REINTERPRET(f64_reinterpret_i64, u64, f64) +)w2c_template" +R"w2c_template(DEFINE_REINTERPRET(i64_reinterpret_f64, f64, u64) +)w2c_template" +R"w2c_template( +static float quiet_nanf(float x) { +)w2c_template" +R"w2c_template( uint32_t tmp; +)w2c_template" +R"w2c_template( memcpy(&tmp, &x, 4); +)w2c_template" +R"w2c_template( tmp |= 0x7fc00000lu; +)w2c_template" +R"w2c_template( memcpy(&x, &tmp, 4); +)w2c_template" +R"w2c_template( return x; +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static double quiet_nan(double x) { +)w2c_template" +R"w2c_template( uint64_t tmp; +)w2c_template" +R"w2c_template( memcpy(&tmp, &x, 8); +)w2c_template" +R"w2c_template( tmp |= 0x7ff8000000000000llu; +)w2c_template" +R"w2c_template( memcpy(&x, &tmp, 8); +)w2c_template" +R"w2c_template( return x; +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static double wasm_quiet(double x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nan(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return x; +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static float wasm_quietf(float x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nanf(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return x; +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static double wasm_floor(double x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nan(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return floor(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static float wasm_floorf(float x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nanf(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return floorf(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static double wasm_ceil(double x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nan(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return ceil(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static float wasm_ceilf(float x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nanf(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return ceilf(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static double wasm_trunc(double x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nan(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return trunc(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static float wasm_truncf(float x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nanf(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return truncf(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static float wasm_nearbyintf(float x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nanf(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return nearbyintf(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static double wasm_nearbyint(double x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nan(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return nearbyint(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static float wasm_fabsf(float x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( uint32_t tmp; +)w2c_template" +R"w2c_template( memcpy(&tmp, &x, 4); +)w2c_template" +R"w2c_template( tmp = tmp & ~(1UL << 31); +)w2c_template" +R"w2c_template( memcpy(&x, &tmp, 4); +)w2c_template" +R"w2c_template( return x; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return fabsf(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static double wasm_fabs(double x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( uint64_t tmp; +)w2c_template" +R"w2c_template( memcpy(&tmp, &x, 8); +)w2c_template" +R"w2c_template( tmp = tmp & ~(1ULL << 63); +)w2c_template" +R"w2c_template( memcpy(&x, &tmp, 8); +)w2c_template" +R"w2c_template( return x; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return fabs(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static double wasm_sqrt(double x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nan(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return sqrt(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static float wasm_sqrtf(float x) { +)w2c_template" +R"w2c_template( if (UNLIKELY(isnan(x))) { +)w2c_template" +R"w2c_template( return quiet_nanf(x); +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( return sqrtf(x); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static inline void memory_fill(wasm_rt_memory_t* mem, u32 d, u32 val, u32 n) { +)w2c_template" +R"w2c_template( RANGE_CHECK(mem, d, n); +)w2c_template" +R"w2c_template( memset(mem->data + d, val, n); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static inline void memory_copy(wasm_rt_memory_t* dest, +)w2c_template" +R"w2c_template( const wasm_rt_memory_t* src, +)w2c_template" +R"w2c_template( u32 dest_addr, +)w2c_template" +R"w2c_template( u32 src_addr, +)w2c_template" +R"w2c_template( u32 n) { +)w2c_template" +R"w2c_template( RANGE_CHECK(dest, dest_addr, n); +)w2c_template" +R"w2c_template( RANGE_CHECK(src, src_addr, n); +)w2c_template" +R"w2c_template( memmove(dest->data + dest_addr, src->data + src_addr, n); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +static inline void memory_init(wasm_rt_memory_t* dest, +)w2c_template" +R"w2c_template( const u8* src, +)w2c_template" +R"w2c_template( u32 src_size, +)w2c_template" +R"w2c_template( u32 dest_addr, +)w2c_template" +R"w2c_template( u32 src_addr, +)w2c_template" +R"w2c_template( u32 n) { +)w2c_template" +R"w2c_template( if (UNLIKELY(src_addr + (uint64_t)n > src_size)) +)w2c_template" +R"w2c_template( TRAP(OOB); +)w2c_template" +R"w2c_template( LOAD_DATA((*dest), dest_addr, src + src_addr, n); +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +typedef struct { +)w2c_template" +R"w2c_template( wasm_rt_func_type_t type; +)w2c_template" +R"w2c_template( wasm_rt_function_ptr_t func; +)w2c_template" +R"w2c_template( size_t module_offset; +)w2c_template" +R"w2c_template(} wasm_elem_segment_expr_t; +)w2c_template" +R"w2c_template( +static inline void funcref_table_init(wasm_rt_funcref_table_t* dest, +)w2c_template" +R"w2c_template( const wasm_elem_segment_expr_t* src, +)w2c_template" +R"w2c_template( u32 src_size, +)w2c_template" +R"w2c_template( u32 dest_addr, +)w2c_template" +R"w2c_template( u32 src_addr, +)w2c_template" +R"w2c_template( u32 n, +)w2c_template" +R"w2c_template( void* module_instance) { +)w2c_template" +R"w2c_template( if (UNLIKELY(src_addr + (uint64_t)n > src_size)) +)w2c_template" +R"w2c_template( TRAP(OOB); +)w2c_template" +R"w2c_template( if (UNLIKELY(dest_addr + (uint64_t)n > dest->size)) +)w2c_template" +R"w2c_template( TRAP(OOB); +)w2c_template" +R"w2c_template( for (u32 i = 0; i < n; i++) { +)w2c_template" +R"w2c_template( const wasm_elem_segment_expr_t* src_expr = &src[src_addr + i]; +)w2c_template" +R"w2c_template( dest->data[dest_addr + i] = +)w2c_template" +R"w2c_template( (wasm_rt_funcref_t){src_expr->type, src_expr->func, +)w2c_template" +R"w2c_template( (char*)module_instance + src_expr->module_offset}; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +// Currently Wasm only supports initializing externref tables with ref.null. +)w2c_template" +R"w2c_template(static inline void externref_table_init(wasm_rt_externref_table_t* dest, +)w2c_template" +R"w2c_template( u32 src_size, +)w2c_template" +R"w2c_template( u32 dest_addr, +)w2c_template" +R"w2c_template( u32 src_addr, +)w2c_template" +R"w2c_template( u32 n) { +)w2c_template" +R"w2c_template( if (UNLIKELY(src_addr + (uint64_t)n > src_size)) +)w2c_template" +R"w2c_template( TRAP(OOB); +)w2c_template" +R"w2c_template( if (UNLIKELY(dest_addr + (uint64_t)n > dest->size)) +)w2c_template" +R"w2c_template( TRAP(OOB); +)w2c_template" +R"w2c_template( for (u32 i = 0; i < n; i++) { +)w2c_template" +R"w2c_template( dest->data[dest_addr + i] = wasm_rt_externref_null_value; +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template(} +)w2c_template" +R"w2c_template( +#define DEFINE_TABLE_COPY(type) \ +)w2c_template" +R"w2c_template( static inline void type##_table_copy(wasm_rt_##type##_table_t* dest, \ +)w2c_template" +R"w2c_template( const wasm_rt_##type##_table_t* src, \ +)w2c_template" +R"w2c_template( u32 dest_addr, u32 src_addr, u32 n) { \ +)w2c_template" +R"w2c_template( if (UNLIKELY(dest_addr + (uint64_t)n > dest->size)) \ +)w2c_template" +R"w2c_template( TRAP(OOB); \ +)w2c_template" +R"w2c_template( if (UNLIKELY(src_addr + (uint64_t)n > src->size)) \ +)w2c_template" +R"w2c_template( TRAP(OOB); \ +)w2c_template" +R"w2c_template( \ +)w2c_template" +R"w2c_template( memmove(dest->data + dest_addr, src->data + src_addr, \ +)w2c_template" +R"w2c_template( n * sizeof(wasm_rt_##type##_t)); \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +DEFINE_TABLE_COPY(funcref) +)w2c_template" +R"w2c_template(DEFINE_TABLE_COPY(externref) +)w2c_template" +R"w2c_template( +#define DEFINE_TABLE_GET(type) \ +)w2c_template" +R"w2c_template( static inline wasm_rt_##type##_t type##_table_get( \ +)w2c_template" +R"w2c_template( const wasm_rt_##type##_table_t* table, u32 i) { \ +)w2c_template" +R"w2c_template( if (UNLIKELY(i >= table->size)) \ +)w2c_template" +R"w2c_template( TRAP(OOB); \ +)w2c_template" +R"w2c_template( return table->data[i]; \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +DEFINE_TABLE_GET(funcref) +)w2c_template" +R"w2c_template(DEFINE_TABLE_GET(externref) +)w2c_template" +R"w2c_template( +#define DEFINE_TABLE_SET(type) \ +)w2c_template" +R"w2c_template( static inline void type##_table_set(const wasm_rt_##type##_table_t* table, \ +)w2c_template" +R"w2c_template( u32 i, const wasm_rt_##type##_t val) { \ +)w2c_template" +R"w2c_template( if (UNLIKELY(i >= table->size)) \ +)w2c_template" +R"w2c_template( TRAP(OOB); \ +)w2c_template" +R"w2c_template( table->data[i] = val; \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +DEFINE_TABLE_SET(funcref) +)w2c_template" +R"w2c_template(DEFINE_TABLE_SET(externref) +)w2c_template" +R"w2c_template( +#define DEFINE_TABLE_FILL(type) \ +)w2c_template" +R"w2c_template( static inline void type##_table_fill(const wasm_rt_##type##_table_t* table, \ +)w2c_template" +R"w2c_template( u32 d, const wasm_rt_##type##_t val, \ +)w2c_template" +R"w2c_template( u32 n) { \ +)w2c_template" +R"w2c_template( if (UNLIKELY((uint64_t)d + n > table->size)) \ +)w2c_template" +R"w2c_template( TRAP(OOB); \ +)w2c_template" +R"w2c_template( for (uint32_t i = d; i < d + n; i++) { \ +)w2c_template" +R"w2c_template( table->data[i] = val; \ +)w2c_template" +R"w2c_template( } \ +)w2c_template" +R"w2c_template( } +)w2c_template" +R"w2c_template( +DEFINE_TABLE_FILL(funcref) +)w2c_template" +R"w2c_template(DEFINE_TABLE_FILL(externref) +)w2c_template" +R"w2c_template( +#if defined(__GNUC__) || defined(__clang__) +)w2c_template" +R"w2c_template(#define FUNC_TYPE_DECL_EXTERN_T(x) extern const char* const x +)w2c_template" +R"w2c_template(#define FUNC_TYPE_EXTERN_T(x) const char* const x +)w2c_template" +R"w2c_template(#define FUNC_TYPE_T(x) static const char* const x +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template(#define FUNC_TYPE_DECL_EXTERN_T(x) extern const char x[] +)w2c_template" +R"w2c_template(#define FUNC_TYPE_EXTERN_T(x) const char x[] +)w2c_template" +R"w2c_template(#define FUNC_TYPE_T(x) static const char x[] +)w2c_template" +R"w2c_template(#endif +)w2c_template" +; diff --git a/third_party/wasm2c/src/prebuilt/wasm2c_source_includes.cc b/third_party/wasm2c/src/prebuilt/wasm2c_source_includes.cc new file mode 100644 index 0000000000..a17c5511b7 --- /dev/null +++ b/third_party/wasm2c/src/prebuilt/wasm2c_source_includes.cc @@ -0,0 +1,33 @@ +const char* s_source_includes = R"w2c_template(#include <assert.h> +)w2c_template" +R"w2c_template(#include <math.h> +)w2c_template" +R"w2c_template(#include <stdarg.h> +)w2c_template" +R"w2c_template(#include <stddef.h> +)w2c_template" +R"w2c_template(#include <string.h> +)w2c_template" +R"w2c_template(#if defined(__MINGW32__) +)w2c_template" +R"w2c_template(#include <malloc.h> +)w2c_template" +R"w2c_template(#elif defined(_MSC_VER) +)w2c_template" +R"w2c_template(#include <intrin.h> +)w2c_template" +R"w2c_template(#include <malloc.h> +)w2c_template" +R"w2c_template(#define alloca _alloca +)w2c_template" +R"w2c_template(#elif defined(__FreeBSD__) || defined(__OpenBSD__) +)w2c_template" +R"w2c_template(#include <stdlib.h> +)w2c_template" +R"w2c_template(#else +)w2c_template" +R"w2c_template(#include <alloca.h> +)w2c_template" +R"w2c_template(#endif +)w2c_template" +; |