1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Assembly Matcher Source Fragment *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* From: WebAssembly.td *|
7|* *|
8\*===----------------------------------------------------------------------===*/
9
10
11#ifdef GET_ASSEMBLER_HEADER
12#undef GET_ASSEMBLER_HEADER
13 // This should be included into the middle of the declaration of
14 // your subclasses implementation of MCTargetAsmParser.
15 FeatureBitset ComputeAvailableFeatures(const FeatureBitset &FB) const;
16 void convertToMCInst(unsigned Kind, MCInst &Inst, unsigned Opcode,
17 const OperandVector &Operands);
18 void convertToMapAndConstraints(unsigned Kind,
19 const OperandVector &Operands) override;
20 unsigned MatchInstructionImpl(const OperandVector &Operands,
21 MCInst &Inst,
22 uint64_t &ErrorInfo,
23 FeatureBitset &MissingFeatures,
24 bool matchingInlineAsm,
25 unsigned VariantID = 0);
26 unsigned MatchInstructionImpl(const OperandVector &Operands,
27 MCInst &Inst,
28 uint64_t &ErrorInfo,
29 bool matchingInlineAsm,
30 unsigned VariantID = 0) {
31 FeatureBitset MissingFeatures;
32 return MatchInstructionImpl(Operands, Inst, ErrorInfo, MissingFeatures,
33 matchingInlineAsm, VariantID);
34 }
35
36#endif // GET_ASSEMBLER_HEADER
37
38
39#ifdef GET_OPERAND_DIAGNOSTIC_TYPES
40#undef GET_OPERAND_DIAGNOSTIC_TYPES
41
42#endif // GET_OPERAND_DIAGNOSTIC_TYPES
43
44
45#ifdef GET_REGISTER_MATCHER
46#undef GET_REGISTER_MATCHER
47
48// Bits for subtarget features that participate in instruction matching.
49enum SubtargetFeatureBits : uint8_t {
50 Feature_HasAtomicsBit = 0,
51 Feature_HasBulkMemoryBit = 1,
52 Feature_HasBulkMemoryOptBit = 2,
53 Feature_HasCallIndirectOverlongBit = 3,
54 Feature_HasExceptionHandlingBit = 4,
55 Feature_HasExtendedConstBit = 5,
56 Feature_HasFP16Bit = 6,
57 Feature_HasMultiMemoryBit = 7,
58 Feature_HasMultivalueBit = 8,
59 Feature_HasMutableGlobalsBit = 9,
60 Feature_HasNontrappingFPToIntBit = 10,
61 Feature_NotHasNontrappingFPToIntBit = 17,
62 Feature_HasReferenceTypesBit = 11,
63 Feature_HasRelaxedSIMDBit = 12,
64 Feature_HasSignExtBit = 14,
65 Feature_HasSIMD128Bit = 13,
66 Feature_HasTailCallBit = 15,
67 Feature_HasWideArithmeticBit = 16,
68};
69
70#endif // GET_REGISTER_MATCHER
71
72
73#ifdef GET_SUBTARGET_FEATURE_NAME
74#undef GET_SUBTARGET_FEATURE_NAME
75
76// User-level names for subtarget features that participate in
77// instruction matching.
78static const char *getSubtargetFeatureName(uint64_t Val) {
79 switch(Val) {
80 case Feature_HasAtomicsBit: return "atomics";
81 case Feature_HasBulkMemoryBit: return "bulk-memory";
82 case Feature_HasBulkMemoryOptBit: return "bulk-memory-opt";
83 case Feature_HasCallIndirectOverlongBit: return "call-indirect-overlong";
84 case Feature_HasExceptionHandlingBit: return "exception-handling";
85 case Feature_HasExtendedConstBit: return "extended-const";
86 case Feature_HasFP16Bit: return "fp16";
87 case Feature_HasMultiMemoryBit: return "multimemory";
88 case Feature_HasMultivalueBit: return "multivalue";
89 case Feature_HasMutableGlobalsBit: return "mutable-globals";
90 case Feature_HasNontrappingFPToIntBit: return "nontrapping-fptoint";
91 case Feature_NotHasNontrappingFPToIntBit: return "nontrapping-fptoint";
92 case Feature_HasReferenceTypesBit: return "reference-types";
93 case Feature_HasRelaxedSIMDBit: return "relaxed-simd";
94 case Feature_HasSignExtBit: return "sign-ext";
95 case Feature_HasSIMD128Bit: return "simd128";
96 case Feature_HasTailCallBit: return "tail-call";
97 case Feature_HasWideArithmeticBit: return "wide-arithmetic";
98 default: return "(unknown)";
99 }
100}
101
102#endif // GET_SUBTARGET_FEATURE_NAME
103
104
105#ifdef GET_MATCHER_IMPLEMENTATION
106#undef GET_MATCHER_IMPLEMENTATION
107
108static const uint8_t TiedAsmOperandTable[][3] = { /* empty */ {0, 0, 0} };
109
110namespace {
111enum OperatorConversionKind {
112 CVT_Done,
113 CVT_Reg,
114 CVT_Tied,
115 CVT_imm_95_0,
116 CVT_95_addImmOperands,
117 CVT_95_addBrListOperands,
118 CVT_95_addFPImmf32Operands,
119 CVT_95_addFPImmf64Operands,
120 CVT_95_addCatchListOperands,
121 CVT_NUM_CONVERTERS
122};
123
124enum InstructionConversionKind {
125 Convert__imm_95_0,
126 Convert__Imm1_0,
127 Convert__BrList1_0,
128 Convert__Imm1_0__Imm1_1,
129 Convert_NoOperands,
130 Convert__imm_95_0__imm_95_0,
131 Convert__FPImmf321_0,
132 Convert__Imm1_1__Imm1_0,
133 Convert__FPImmf641_0,
134 Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3__Imm1_4__Imm1_5__Imm1_6__Imm1_7__Imm1_8__Imm1_9__Imm1_10__Imm1_11__Imm1_12__Imm1_13__Imm1_14__Imm1_15,
135 Convert__Imm1_0__CatchList1_1,
136 Convert__FPImmf641_0__FPImmf641_1,
137 Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3,
138 Convert__FPImmf321_0__FPImmf321_1__FPImmf321_2__FPImmf321_3,
139 Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3__Imm1_4__Imm1_5__Imm1_6__Imm1_7,
140 Convert__Imm1_1__Imm1_0__Imm1_2,
141 CVT_NUM_SIGNATURES
142};
143
144} // end anonymous namespace
145
146static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][33] = {
147 // Convert__imm_95_0
148 { CVT_imm_95_0, 0, CVT_Done },
149 // Convert__Imm1_0
150 { CVT_95_addImmOperands, 1, CVT_Done },
151 // Convert__BrList1_0
152 { CVT_95_addBrListOperands, 1, CVT_Done },
153 // Convert__Imm1_0__Imm1_1
154 { CVT_95_addImmOperands, 1, CVT_95_addImmOperands, 2, CVT_Done },
155 // Convert_NoOperands
156 { CVT_Done },
157 // Convert__imm_95_0__imm_95_0
158 { CVT_imm_95_0, 0, CVT_imm_95_0, 0, CVT_Done },
159 // Convert__FPImmf321_0
160 { CVT_95_addFPImmf32Operands, 1, CVT_Done },
161 // Convert__Imm1_1__Imm1_0
162 { CVT_95_addImmOperands, 2, CVT_95_addImmOperands, 1, CVT_Done },
163 // Convert__FPImmf641_0
164 { CVT_95_addFPImmf64Operands, 1, CVT_Done },
165 // Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3__Imm1_4__Imm1_5__Imm1_6__Imm1_7__Imm1_8__Imm1_9__Imm1_10__Imm1_11__Imm1_12__Imm1_13__Imm1_14__Imm1_15
166 { CVT_95_addImmOperands, 1, CVT_95_addImmOperands, 2, CVT_95_addImmOperands, 3, CVT_95_addImmOperands, 4, CVT_95_addImmOperands, 5, CVT_95_addImmOperands, 6, CVT_95_addImmOperands, 7, CVT_95_addImmOperands, 8, CVT_95_addImmOperands, 9, CVT_95_addImmOperands, 10, CVT_95_addImmOperands, 11, CVT_95_addImmOperands, 12, CVT_95_addImmOperands, 13, CVT_95_addImmOperands, 14, CVT_95_addImmOperands, 15, CVT_95_addImmOperands, 16, CVT_Done },
167 // Convert__Imm1_0__CatchList1_1
168 { CVT_95_addImmOperands, 1, CVT_95_addCatchListOperands, 2, CVT_Done },
169 // Convert__FPImmf641_0__FPImmf641_1
170 { CVT_95_addFPImmf64Operands, 1, CVT_95_addFPImmf64Operands, 2, CVT_Done },
171 // Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3
172 { CVT_95_addImmOperands, 1, CVT_95_addImmOperands, 2, CVT_95_addImmOperands, 3, CVT_95_addImmOperands, 4, CVT_Done },
173 // Convert__FPImmf321_0__FPImmf321_1__FPImmf321_2__FPImmf321_3
174 { CVT_95_addFPImmf32Operands, 1, CVT_95_addFPImmf32Operands, 2, CVT_95_addFPImmf32Operands, 3, CVT_95_addFPImmf32Operands, 4, CVT_Done },
175 // Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3__Imm1_4__Imm1_5__Imm1_6__Imm1_7
176 { CVT_95_addImmOperands, 1, CVT_95_addImmOperands, 2, CVT_95_addImmOperands, 3, CVT_95_addImmOperands, 4, CVT_95_addImmOperands, 5, CVT_95_addImmOperands, 6, CVT_95_addImmOperands, 7, CVT_95_addImmOperands, 8, CVT_Done },
177 // Convert__Imm1_1__Imm1_0__Imm1_2
178 { CVT_95_addImmOperands, 2, CVT_95_addImmOperands, 1, CVT_95_addImmOperands, 3, CVT_Done },
179};
180
181void WebAssemblyAsmParser::
182convertToMCInst(unsigned Kind, MCInst &Inst, unsigned Opcode,
183 const OperandVector &Operands) {
184 assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
185 const uint8_t *Converter = ConversionTable[Kind];
186 Inst.setOpcode(Opcode);
187 for (const uint8_t *p = Converter; *p; p += 2) {
188 unsigned OpIdx = *(p + 1);
189 switch (*p) {
190 default: llvm_unreachable("invalid conversion entry!");
191 case CVT_Reg:
192 static_cast<WebAssemblyOperand &>(*Operands[OpIdx]).addRegOperands(Inst, 1);
193 break;
194 case CVT_Tied: {
195 assert(*(p + 1) < (size_t)(std::end(TiedAsmOperandTable) -
196 std::begin(TiedAsmOperandTable)) &&
197 "Tied operand not found");
198 unsigned TiedResOpnd = TiedAsmOperandTable[*(p + 1)][0];
199 if (TiedResOpnd != (uint8_t)-1)
200 Inst.addOperand(Inst.getOperand(TiedResOpnd));
201 break;
202 }
203 case CVT_imm_95_0:
204 Inst.addOperand(MCOperand::createImm(0));
205 break;
206 case CVT_95_addImmOperands:
207 static_cast<WebAssemblyOperand &>(*Operands[OpIdx]).addImmOperands(Inst, 1);
208 break;
209 case CVT_95_addBrListOperands:
210 static_cast<WebAssemblyOperand &>(*Operands[OpIdx]).addBrListOperands(Inst, 1);
211 break;
212 case CVT_95_addFPImmf32Operands:
213 static_cast<WebAssemblyOperand &>(*Operands[OpIdx]).addFPImmf32Operands(Inst, 1);
214 break;
215 case CVT_95_addFPImmf64Operands:
216 static_cast<WebAssemblyOperand &>(*Operands[OpIdx]).addFPImmf64Operands(Inst, 1);
217 break;
218 case CVT_95_addCatchListOperands:
219 static_cast<WebAssemblyOperand &>(*Operands[OpIdx]).addCatchListOperands(Inst, 1);
220 break;
221 }
222 }
223}
224
225void WebAssemblyAsmParser::
226convertToMapAndConstraints(unsigned Kind,
227 const OperandVector &Operands) {
228 assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
229 unsigned NumMCOperands = 0;
230 const uint8_t *Converter = ConversionTable[Kind];
231 for (const uint8_t *p = Converter; *p; p += 2) {
232 switch (*p) {
233 default: llvm_unreachable("invalid conversion entry!");
234 case CVT_Reg:
235 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
236 Operands[*(p + 1)]->setConstraint("r");
237 ++NumMCOperands;
238 break;
239 case CVT_Tied:
240 ++NumMCOperands;
241 break;
242 case CVT_imm_95_0:
243 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
244 Operands[*(p + 1)]->setConstraint("");
245 ++NumMCOperands;
246 break;
247 case CVT_95_addImmOperands:
248 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
249 Operands[*(p + 1)]->setConstraint("m");
250 NumMCOperands += 1;
251 break;
252 case CVT_95_addBrListOperands:
253 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
254 Operands[*(p + 1)]->setConstraint("m");
255 NumMCOperands += 1;
256 break;
257 case CVT_95_addFPImmf32Operands:
258 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
259 Operands[*(p + 1)]->setConstraint("m");
260 NumMCOperands += 1;
261 break;
262 case CVT_95_addFPImmf64Operands:
263 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
264 Operands[*(p + 1)]->setConstraint("m");
265 NumMCOperands += 1;
266 break;
267 case CVT_95_addCatchListOperands:
268 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
269 Operands[*(p + 1)]->setConstraint("m");
270 NumMCOperands += 1;
271 break;
272 }
273 }
274}
275
276namespace {
277
278/// MatchClassKind - The kinds of classes which participate in
279/// instruction matching.
280enum MatchClassKind {
281 InvalidMatchClass = 0,
282 OptionalMatchClass = 1,
283 MCK_LAST_TOKEN = OptionalMatchClass,
284 MCK_EXNREF, // register class 'EXNREF'
285 MCK_EXTERNREF, // register class 'EXTERNREF'
286 MCK_F32, // register class 'F32'
287 MCK_F64, // register class 'F64'
288 MCK_FUNCREF, // register class 'FUNCREF'
289 MCK_V128, // register class 'V128'
290 MCK_I32, // register class 'I32'
291 MCK_I64, // register class 'I64'
292 MCK_LAST_REGISTER = MCK_I64,
293 MCK_BrList, // user defined class 'BrListAsmOperand'
294 MCK_CatchList, // user defined class 'CatchListAsmOperand'
295 MCK_Imm, // user defined class 'ImmAsmOperand'
296 MCK_FPImmf32, // user defined class 'anonymous_8654'
297 MCK_FPImmf64, // user defined class 'anonymous_8655'
298 NumMatchClassKinds
299};
300
301} // end anonymous namespace
302
303static unsigned getDiagKindFromRegisterClass(MatchClassKind RegisterClass) {
304 return MCTargetAsmParser::Match_InvalidOperand;
305}
306
307static MatchClassKind matchTokenString(StringRef Name) {
308 return InvalidMatchClass;
309}
310
311/// isSubclass - Compute whether \p A is a subclass of \p B.
312static bool isSubclass(MatchClassKind A, MatchClassKind B) {
313 if (A == B)
314 return true;
315
316 [[maybe_unused]] static constexpr struct {
317 uint32_t Offset;
318 uint16_t Start;
319 uint16_t Length;
320 } Table[] = {
321 {0, 0, 0},
322 {0, 0, 0},
323 {0, 0, 0},
324 {0, 0, 0},
325 {0, 0, 0},
326 {0, 0, 0},
327 {0, 0, 0},
328 {0, 0, 0},
329 {0, 0, 0},
330 {0, 0, 0},
331 {0, 0, 0},
332 {0, 0, 0},
333 {0, 0, 0},
334 {0, 0, 0},
335 {0, 0, 0},
336 };
337
338 return false;
339}
340
341static unsigned validateOperandClass(MCParsedAsmOperand &GOp, MatchClassKind Kind) {
342 WebAssemblyOperand &Operand = (WebAssemblyOperand &)GOp;
343 if (Kind == InvalidMatchClass)
344 return MCTargetAsmParser::Match_InvalidOperand;
345
346 if (Operand.isToken() && Kind <= MCK_LAST_TOKEN)
347 return isSubclass(matchTokenString(Operand.getToken()), Kind) ?
348 MCTargetAsmParser::Match_Success :
349 MCTargetAsmParser::Match_InvalidOperand;
350
351 switch (Kind) {
352 default: break;
353 case MCK_BrList: {
354 DiagnosticPredicate DP(Operand.isBrList());
355 if (DP.isMatch())
356 return MCTargetAsmParser::Match_Success;
357 break;
358 }
359 case MCK_CatchList: {
360 DiagnosticPredicate DP(Operand.isCatchList());
361 if (DP.isMatch())
362 return MCTargetAsmParser::Match_Success;
363 break;
364 }
365 case MCK_Imm: {
366 DiagnosticPredicate DP(Operand.isImm());
367 if (DP.isMatch())
368 return MCTargetAsmParser::Match_Success;
369 break;
370 }
371 case MCK_FPImmf32: {
372 DiagnosticPredicate DP(Operand.isFPImm());
373 if (DP.isMatch())
374 return MCTargetAsmParser::Match_Success;
375 break;
376 }
377 case MCK_FPImmf64: {
378 DiagnosticPredicate DP(Operand.isFPImm());
379 if (DP.isMatch())
380 return MCTargetAsmParser::Match_Success;
381 break;
382 }
383 } // end switch (Kind)
384
385 if (Operand.isReg()) {
386 static constexpr uint16_t Table[WebAssembly::NUM_TARGET_REGS] = {
387 InvalidMatchClass,
388 InvalidMatchClass,
389 InvalidMatchClass,
390 MCK_EXNREF,
391 MCK_EXTERNREF,
392 MCK_I32,
393 MCK_I64,
394 MCK_FUNCREF,
395 MCK_I32,
396 MCK_I64,
397 MCK_F32,
398 MCK_F64,
399 MCK_I32,
400 MCK_I64,
401 MCK_V128,
402 };
403
404 MCRegister Reg = Operand.getReg();
405 MatchClassKind OpKind = Reg.isPhysical() ? (MatchClassKind)Table[Reg.id()] : InvalidMatchClass;
406 return isSubclass(OpKind, Kind) ? (unsigned)MCTargetAsmParser::Match_Success :
407 getDiagKindFromRegisterClass(Kind);
408 }
409
410 if (Kind > MCK_LAST_TOKEN && Kind <= MCK_LAST_REGISTER)
411 return getDiagKindFromRegisterClass(Kind);
412
413 return MCTargetAsmParser::Match_InvalidOperand;
414}
415
416#ifndef NDEBUG
417const char *getMatchClassName(MatchClassKind Kind) {
418 switch (Kind) {
419 case InvalidMatchClass: return "InvalidMatchClass";
420 case OptionalMatchClass: return "OptionalMatchClass";
421 case MCK_EXNREF: return "MCK_EXNREF";
422 case MCK_EXTERNREF: return "MCK_EXTERNREF";
423 case MCK_F32: return "MCK_F32";
424 case MCK_F64: return "MCK_F64";
425 case MCK_FUNCREF: return "MCK_FUNCREF";
426 case MCK_V128: return "MCK_V128";
427 case MCK_I32: return "MCK_I32";
428 case MCK_I64: return "MCK_I64";
429 case MCK_BrList: return "MCK_BrList";
430 case MCK_CatchList: return "MCK_CatchList";
431 case MCK_Imm: return "MCK_Imm";
432 case MCK_FPImmf32: return "MCK_FPImmf32";
433 case MCK_FPImmf64: return "MCK_FPImmf64";
434 case NumMatchClassKinds: return "NumMatchClassKinds";
435 }
436 llvm_unreachable("unhandled MatchClassKind!");
437}
438
439#endif // NDEBUG
440FeatureBitset WebAssemblyAsmParser::
441ComputeAvailableFeatures(const FeatureBitset &FB) const {
442 FeatureBitset Features;
443 if (FB[WebAssembly::FeatureAtomics])
444 Features.set(Feature_HasAtomicsBit);
445 if (FB[WebAssembly::FeatureBulkMemory])
446 Features.set(Feature_HasBulkMemoryBit);
447 if (FB[WebAssembly::FeatureBulkMemoryOpt])
448 Features.set(Feature_HasBulkMemoryOptBit);
449 if (FB[WebAssembly::FeatureCallIndirectOverlong])
450 Features.set(Feature_HasCallIndirectOverlongBit);
451 if (FB[WebAssembly::FeatureExceptionHandling])
452 Features.set(Feature_HasExceptionHandlingBit);
453 if (FB[WebAssembly::FeatureExtendedConst])
454 Features.set(Feature_HasExtendedConstBit);
455 if (FB[WebAssembly::FeatureFP16])
456 Features.set(Feature_HasFP16Bit);
457 if (FB[WebAssembly::FeatureMultiMemory])
458 Features.set(Feature_HasMultiMemoryBit);
459 if (FB[WebAssembly::FeatureMultivalue])
460 Features.set(Feature_HasMultivalueBit);
461 if (FB[WebAssembly::FeatureMutableGlobals])
462 Features.set(Feature_HasMutableGlobalsBit);
463 if (FB[WebAssembly::FeatureNontrappingFPToInt])
464 Features.set(Feature_HasNontrappingFPToIntBit);
465 if (!FB[WebAssembly::FeatureNontrappingFPToInt])
466 Features.set(Feature_NotHasNontrappingFPToIntBit);
467 if (FB[WebAssembly::FeatureReferenceTypes])
468 Features.set(Feature_HasReferenceTypesBit);
469 if (FB[WebAssembly::FeatureRelaxedSIMD])
470 Features.set(Feature_HasRelaxedSIMDBit);
471 if (FB[WebAssembly::FeatureSignExt])
472 Features.set(Feature_HasSignExtBit);
473 if (FB[WebAssembly::FeatureSIMD128] || FB[WebAssembly::FeatureRelaxedSIMD])
474 Features.set(Feature_HasSIMD128Bit);
475 if (FB[WebAssembly::FeatureTailCall])
476 Features.set(Feature_HasTailCallBit);
477 if (FB[WebAssembly::FeatureWideArithmetic])
478 Features.set(Feature_HasWideArithmeticBit);
479 return Features;
480}
481
482static bool checkAsmTiedOperandConstraints(const WebAssemblyAsmParser&AsmParser,
483 unsigned Kind, const OperandVector &Operands,
484 uint64_t &ErrorInfo) {
485 assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
486 const uint8_t *Converter = ConversionTable[Kind];
487 for (const uint8_t *p = Converter; *p; p += 2) {
488 switch (*p) {
489 case CVT_Tied: {
490 unsigned OpIdx = *(p + 1);
491 assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
492 std::begin(TiedAsmOperandTable)) &&
493 "Tied operand not found");
494 unsigned OpndNum1 = TiedAsmOperandTable[OpIdx][1];
495 unsigned OpndNum2 = TiedAsmOperandTable[OpIdx][2];
496 if (OpndNum1 != OpndNum2) {
497 auto &SrcOp1 = Operands[OpndNum1];
498 auto &SrcOp2 = Operands[OpndNum2];
499 if (!AsmParser.areEqualRegs(*SrcOp1, *SrcOp2)) {
500 ErrorInfo = OpndNum2;
501 return false;
502 }
503 }
504 break;
505 }
506 default:
507 break;
508 }
509 }
510 return true;
511}
512
513static const char MnemonicTable[] =
514 "\000\014atomic.fence\005block\002br\005br_if\010br_table\004call\015cal"
515 "l_indirect\013call_params\014call_results\005catch\tcatch_all\010catchr"
516 "et\ncleanupret\016compiler_fence\tdata.drop\010delegate\004drop\004else"
517 "\003end\tend_block\014end_function\006end_if\010end_loop\007end_try\015"
518 "end_try_table\015exnref.select\020externref.select\tf16x8.abs\tf16x8.ad"
519 "d\nf16x8.ceil\025f16x8.convert_i16x8_s\025f16x8.convert_i16x8_u\tf16x8."
520 "div\010f16x8.eq\022f16x8.extract_lane\013f16x8.floor\010f16x8.ge\010f16"
521 "x8.gt\010f16x8.le\010f16x8.lt\tf16x8.max\tf16x8.min\tf16x8.mul\010f16x8"
522 ".ne\015f16x8.nearest\tf16x8.neg\nf16x8.pmax\nf16x8.pmin\022f16x8.relaxe"
523 "d_madd\023f16x8.relaxed_nmadd\022f16x8.replace_lane\013f16x8.splat\nf16"
524 "x8.sqrt\tf16x8.sub\013f16x8.trunc\007f32.abs\007f32.add\010f32.ceil\tf3"
525 "2.const\021f32.convert_i32_s\021f32.convert_i32_u\021f32.convert_i64_s\021"
526 "f32.convert_i64_u\014f32.copysign\016f32.demote_f64\007f32.div\006f32.e"
527 "q\tf32.floor\006f32.ge\006f32.gt\006f32.le\010f32.load\014f32.load_f16\006"
528 "f32.lt\007f32.max\007f32.min\007f32.mul\006f32.ne\013f32.nearest\007f32"
529 ".neg\023f32.reinterpret_i32\nf32.select\010f32.sqrt\tf32.store\015f32.s"
530 "tore_f16\007f32.sub\tf32.trunc\tf32x4.abs\tf32x4.add\nf32x4.ceil\025f32"
531 "x4.convert_i32x4_s\025f32x4.convert_i32x4_u\027f32x4.demote_f64x2_zero\t"
532 "f32x4.div\010f32x4.eq\022f32x4.extract_lane\013f32x4.floor\010f32x4.ge\010"
533 "f32x4.gt\010f32x4.le\010f32x4.lt\tf32x4.max\tf32x4.min\tf32x4.mul\010f3"
534 "2x4.ne\015f32x4.nearest\tf32x4.neg\nf32x4.pmax\nf32x4.pmin f32x4.relaxe"
535 "d_dot_bf16x8_add_f32\022f32x4.relaxed_madd\021f32x4.relaxed_max\021f32x"
536 "4.relaxed_min\023f32x4.relaxed_nmadd\022f32x4.replace_lane\013f32x4.spl"
537 "at\nf32x4.sqrt\tf32x4.sub\013f32x4.trunc\007f64.abs\007f64.add\010f64.c"
538 "eil\tf64.const\021f64.convert_i32_s\021f64.convert_i32_u\021f64.convert"
539 "_i64_s\021f64.convert_i64_u\014f64.copysign\007f64.div\006f64.eq\tf64.f"
540 "loor\006f64.ge\006f64.gt\006f64.le\010f64.load\006f64.lt\007f64.max\007"
541 "f64.min\007f64.mul\006f64.ne\013f64.nearest\007f64.neg\017f64.promote_f"
542 "32\023f64.reinterpret_i64\nf64.select\010f64.sqrt\tf64.store\007f64.sub"
543 "\tf64.trunc\tf64x2.abs\tf64x2.add\nf64x2.ceil\031f64x2.convert_low_i32x"
544 "4_s\031f64x2.convert_low_i32x4_u\tf64x2.div\010f64x2.eq\022f64x2.extrac"
545 "t_lane\013f64x2.floor\010f64x2.ge\010f64x2.gt\010f64x2.le\010f64x2.lt\t"
546 "f64x2.max\tf64x2.min\tf64x2.mul\010f64x2.ne\015f64x2.nearest\tf64x2.neg"
547 "\nf64x2.pmax\nf64x2.pmin\027f64x2.promote_low_f32x4\022f64x2.relaxed_ma"
548 "dd\021f64x2.relaxed_max\021f64x2.relaxed_min\023f64x2.relaxed_nmadd\022"
549 "f64x2.replace_lane\013f64x2.splat\nf64x2.sqrt\tf64x2.sub\013f64x2.trunc"
550 "\016funcref.select\nglobal.get\nglobal.set\ti16x8.abs\ti16x8.add\017i16"
551 "x8.add_sat_s\017i16x8.add_sat_u\016i16x8.all_true\014i16x8.avgr_u\015i1"
552 "6x8.bitmask\010i16x8.eq\035i16x8.extadd_pairwise_i8x16_s\035i16x8.extad"
553 "d_pairwise_i8x16_u\031i16x8.extend_high_i8x16_s\031i16x8.extend_high_i8"
554 "x16_u\030i16x8.extend_low_i8x16_s\030i16x8.extend_low_i8x16_u\031i16x8."
555 "extmul_high_i8x16_s\031i16x8.extmul_high_i8x16_u\030i16x8.extmul_low_i8"
556 "x16_s\030i16x8.extmul_low_i8x16_u\024i16x8.extract_lane_s\024i16x8.extr"
557 "act_lane_u\ni16x8.ge_s\ni16x8.ge_u\ni16x8.gt_s\ni16x8.gt_u\ni16x8.le_s\n"
558 "i16x8.le_u\017i16x8.load8x8_s\017i16x8.load8x8_u\ni16x8.lt_s\ni16x8.lt_"
559 "u\013i16x8.max_s\013i16x8.max_u\013i16x8.min_s\013i16x8.min_u\ti16x8.mu"
560 "l\024i16x8.narrow_i32x4_s\024i16x8.narrow_i32x4_u\010i16x8.ne\ti16x8.ne"
561 "g\023i16x8.q15mulr_sat_s\037i16x8.relaxed_dot_i8x16_i7x16_s\030i16x8.re"
562 "laxed_laneselect\027i16x8.relaxed_q15mulr_s\022i16x8.replace_lane\ti16x"
563 "8.shl\013i16x8.shr_s\013i16x8.shr_u\013i16x8.splat\ti16x8.sub\017i16x8."
564 "sub_sat_s\017i16x8.sub_sat_u\027i16x8.trunc_sat_f16x8_s\027i16x8.trunc_"
565 "sat_f16x8_u\007i32.add\007i32.and\017i32.atomic.load\023i32.atomic.load"
566 "16_u\022i32.atomic.load8_u\022i32.atomic.rmw.add\022i32.atomic.rmw.and\026"
567 "i32.atomic.rmw.cmpxchg\021i32.atomic.rmw.or\022i32.atomic.rmw.sub\023i3"
568 "2.atomic.rmw.xchg\022i32.atomic.rmw.xor\026i32.atomic.rmw16.add_u\026i3"
569 "2.atomic.rmw16.and_u\032i32.atomic.rmw16.cmpxchg_u\025i32.atomic.rmw16."
570 "or_u\026i32.atomic.rmw16.sub_u\027i32.atomic.rmw16.xchg_u\026i32.atomic"
571 ".rmw16.xor_u\025i32.atomic.rmw8.add_u\025i32.atomic.rmw8.and_u\031i32.a"
572 "tomic.rmw8.cmpxchg_u\024i32.atomic.rmw8.or_u\025i32.atomic.rmw8.sub_u\026"
573 "i32.atomic.rmw8.xchg_u\025i32.atomic.rmw8.xor_u\020i32.atomic.store\022"
574 "i32.atomic.store16\021i32.atomic.store8\007i32.clz\ti32.const\007i32.ct"
575 "z\ti32.div_s\ti32.div_u\006i32.eq\007i32.eqz\016i32.extend16_s\015i32.e"
576 "xtend8_s\010i32.ge_s\010i32.ge_u\010i32.gt_s\010i32.gt_u\010i32.le_s\010"
577 "i32.le_u\010i32.load\014i32.load16_s\014i32.load16_u\013i32.load8_s\013"
578 "i32.load8_u\010i32.lt_s\010i32.lt_u\007i32.mul\006i32.ne\006i32.or\ni32"
579 ".popcnt\023i32.reinterpret_f32\ti32.rem_s\ti32.rem_u\010i32.rotl\010i32"
580 ".rotr\ni32.select\007i32.shl\ti32.shr_s\ti32.shr_u\ti32.store\013i32.st"
581 "ore16\ni32.store8\007i32.sub\017i32.trunc_f32_s\017i32.trunc_f32_u\017i"
582 "32.trunc_f64_s\017i32.trunc_f64_u\023i32.trunc_sat_f32_s\023i32.trunc_s"
583 "at_f32_u\023i32.trunc_sat_f64_s\023i32.trunc_sat_f64_u\014i32.wrap_i64\007"
584 "i32.xor\ti32x4.abs\ti32x4.add\016i32x4.all_true\015i32x4.bitmask\021i32"
585 "x4.dot_i16x8_s\010i32x4.eq\035i32x4.extadd_pairwise_i16x8_s\035i32x4.ex"
586 "tadd_pairwise_i16x8_u\031i32x4.extend_high_i16x8_s\031i32x4.extend_high"
587 "_i16x8_u\030i32x4.extend_low_i16x8_s\030i32x4.extend_low_i16x8_u\031i32"
588 "x4.extmul_high_i16x8_s\031i32x4.extmul_high_i16x8_u\030i32x4.extmul_low"
589 "_i16x8_s\030i32x4.extmul_low_i16x8_u\022i32x4.extract_lane\ni32x4.ge_s\n"
590 "i32x4.ge_u\ni32x4.gt_s\ni32x4.gt_u\ni32x4.le_s\ni32x4.le_u\020i32x4.loa"
591 "d16x4_s\020i32x4.load16x4_u\ni32x4.lt_s\ni32x4.lt_u\013i32x4.max_s\013i"
592 "32x4.max_u\013i32x4.min_s\013i32x4.min_u\ti32x4.mul\010i32x4.ne\ti32x4."
593 "neg#i32x4.relaxed_dot_i8x16_i7x16_add_s\030i32x4.relaxed_laneselect\033"
594 "i32x4.relaxed_trunc_f32x4_s\033i32x4.relaxed_trunc_f32x4_u i32x4.relaxe"
595 "d_trunc_f64x2_s_zero i32x4.relaxed_trunc_f64x2_u_zero\022i32x4.replace_"
596 "lane\ti32x4.shl\013i32x4.shr_s\013i32x4.shr_u\013i32x4.splat\ti32x4.sub"
597 "\027i32x4.trunc_sat_f32x4_s\027i32x4.trunc_sat_f32x4_u\034i32x4.trunc_s"
598 "at_f64x2_s_zero\034i32x4.trunc_sat_f64x2_u_zero\007i64.add\ni64.add128\007"
599 "i64.and\017i64.atomic.load\023i64.atomic.load16_u\023i64.atomic.load32_"
600 "u\022i64.atomic.load8_u\022i64.atomic.rmw.add\022i64.atomic.rmw.and\026"
601 "i64.atomic.rmw.cmpxchg\021i64.atomic.rmw.or\022i64.atomic.rmw.sub\023i6"
602 "4.atomic.rmw.xchg\022i64.atomic.rmw.xor\026i64.atomic.rmw16.add_u\026i6"
603 "4.atomic.rmw16.and_u\032i64.atomic.rmw16.cmpxchg_u\025i64.atomic.rmw16."
604 "or_u\026i64.atomic.rmw16.sub_u\027i64.atomic.rmw16.xchg_u\026i64.atomic"
605 ".rmw16.xor_u\026i64.atomic.rmw32.add_u\026i64.atomic.rmw32.and_u\032i64"
606 ".atomic.rmw32.cmpxchg_u\025i64.atomic.rmw32.or_u\026i64.atomic.rmw32.su"
607 "b_u\027i64.atomic.rmw32.xchg_u\026i64.atomic.rmw32.xor_u\025i64.atomic."
608 "rmw8.add_u\025i64.atomic.rmw8.and_u\031i64.atomic.rmw8.cmpxchg_u\024i64"
609 ".atomic.rmw8.or_u\025i64.atomic.rmw8.sub_u\026i64.atomic.rmw8.xchg_u\025"
610 "i64.atomic.rmw8.xor_u\020i64.atomic.store\022i64.atomic.store16\022i64."
611 "atomic.store32\021i64.atomic.store8\007i64.clz\ti64.const\007i64.ctz\ti"
612 "64.div_s\ti64.div_u\006i64.eq\007i64.eqz\016i64.extend16_s\016i64.exten"
613 "d32_s\015i64.extend8_s\020i64.extend_i32_s\020i64.extend_i32_u\010i64.g"
614 "e_s\010i64.ge_u\010i64.gt_s\010i64.gt_u\010i64.le_s\010i64.le_u\010i64."
615 "load\014i64.load16_s\014i64.load16_u\014i64.load32_s\014i64.load32_u\013"
616 "i64.load8_s\013i64.load8_u\010i64.lt_s\010i64.lt_u\007i64.mul\016i64.mu"
617 "l_wide_s\016i64.mul_wide_u\006i64.ne\006i64.or\ni64.popcnt\023i64.reint"
618 "erpret_f64\ti64.rem_s\ti64.rem_u\010i64.rotl\010i64.rotr\ni64.select\007"
619 "i64.shl\ti64.shr_s\ti64.shr_u\ti64.store\013i64.store16\013i64.store32\n"
620 "i64.store8\007i64.sub\ni64.sub128\017i64.trunc_f32_s\017i64.trunc_f32_u"
621 "\017i64.trunc_f64_s\017i64.trunc_f64_u\023i64.trunc_sat_f32_s\023i64.tr"
622 "unc_sat_f32_u\023i64.trunc_sat_f64_s\023i64.trunc_sat_f64_u\007i64.xor\t"
623 "i64x2.abs\ti64x2.add\016i64x2.all_true\015i64x2.bitmask\010i64x2.eq\031"
624 "i64x2.extend_high_i32x4_s\031i64x2.extend_high_i32x4_u\030i64x2.extend_"
625 "low_i32x4_s\030i64x2.extend_low_i32x4_u\031i64x2.extmul_high_i32x4_s\031"
626 "i64x2.extmul_high_i32x4_u\030i64x2.extmul_low_i32x4_s\030i64x2.extmul_l"
627 "ow_i32x4_u\022i64x2.extract_lane\ni64x2.ge_s\ni64x2.gt_s\ni64x2.le_s\020"
628 "i64x2.load32x2_s\020i64x2.load32x2_u\ni64x2.lt_s\ti64x2.mul\010i64x2.ne"
629 "\ti64x2.neg\030i64x2.relaxed_laneselect\022i64x2.replace_lane\ti64x2.sh"
630 "l\013i64x2.shr_s\013i64x2.shr_u\013i64x2.splat\ti64x2.sub\ti8x16.abs\ti"
631 "8x16.add\017i8x16.add_sat_s\017i8x16.add_sat_u\016i8x16.all_true\014i8x"
632 "16.avgr_u\015i8x16.bitmask\010i8x16.eq\024i8x16.extract_lane_s\024i8x16"
633 ".extract_lane_u\ni8x16.ge_s\ni8x16.ge_u\ni8x16.gt_s\ni8x16.gt_u\ni8x16."
634 "le_s\ni8x16.le_u\ni8x16.lt_s\ni8x16.lt_u\013i8x16.max_s\013i8x16.max_u\013"
635 "i8x16.min_s\013i8x16.min_u\024i8x16.narrow_i16x8_s\024i8x16.narrow_i16x"
636 "8_u\010i8x16.ne\ti8x16.neg\014i8x16.popcnt\030i8x16.relaxed_laneselect\025"
637 "i8x16.relaxed_swizzle\022i8x16.replace_lane\ti8x16.shl\013i8x16.shr_s\013"
638 "i8x16.shr_u\015i8x16.shuffle\013i8x16.splat\ti8x16.sub\017i8x16.sub_sat"
639 "_s\017i8x16.sub_sat_u\015i8x16.swizzle\002if\tlocal.get\tlocal.set\tloc"
640 "al.tee\004loop\024memory.atomic.notify\024memory.atomic.wait32\024memor"
641 "y.atomic.wait64\013memory.copy\013memory.fill\013memory.grow\013memory."
642 "init\013memory.size\003nop\013ref.is_null\014ref.null_exn\017ref.null_e"
643 "xtern\015ref.null_func\007rethrow\006return\013return_call\024return_ca"
644 "ll_indirect\023return_call_results\ntable.copy\ntable.fill\ttable.get\n"
645 "table.grow\ttable.set\ntable.size\005throw\tthrow_ref\003try\ttry_table"
646 "\013unreachable\010v128.and\013v128.andnot\015v128.any_true\016v128.bit"
647 "select\nv128.const\tv128.load\020v128.load16_lane\021v128.load16_splat\020"
648 "v128.load32_lane\021v128.load32_splat\020v128.load32_zero\020v128.load6"
649 "4_lane\021v128.load64_splat\020v128.load64_zero\017v128.load8_lane\020v"
650 "128.load8_splat\010v128.not\007v128.or\013v128.select\nv128.store\021v1"
651 "28.store16_lane\021v128.store32_lane\021v128.store64_lane\020v128.store"
652 "8_lane\010v128.xor";
653
654// Feature bitsets.
655enum : uint8_t {
656 AMFBS_None,
657 AMFBS_HasAtomics,
658 AMFBS_HasBulkMemoryOpt,
659 AMFBS_HasExceptionHandling,
660 AMFBS_HasFP16,
661 AMFBS_HasNontrappingFPToInt,
662 AMFBS_HasReferenceTypes,
663 AMFBS_HasRelaxedSIMD,
664 AMFBS_HasSIMD128,
665 AMFBS_HasSignExt,
666 AMFBS_HasTailCall,
667 AMFBS_HasWideArithmetic,
668 AMFBS_HasReferenceTypes_HasExceptionHandling,
669 AMFBS_HasSIMD128_HasFP16,
670 AMFBS_HasSIMD128_HasRelaxedSIMD,
671};
672
673static constexpr FeatureBitset FeatureBitsets[] = {
674 {}, // AMFBS_None
675 {Feature_HasAtomicsBit, },
676 {Feature_HasBulkMemoryOptBit, },
677 {Feature_HasExceptionHandlingBit, },
678 {Feature_HasFP16Bit, },
679 {Feature_HasNontrappingFPToIntBit, },
680 {Feature_HasReferenceTypesBit, },
681 {Feature_HasRelaxedSIMDBit, },
682 {Feature_HasSIMD128Bit, },
683 {Feature_HasSignExtBit, },
684 {Feature_HasTailCallBit, },
685 {Feature_HasWideArithmeticBit, },
686 {Feature_HasReferenceTypesBit, Feature_HasExceptionHandlingBit, },
687 {Feature_HasSIMD128Bit, Feature_HasFP16Bit, },
688 {Feature_HasSIMD128Bit, Feature_HasRelaxedSIMDBit, },
689};
690
691namespace {
692 struct MatchEntry {
693 uint16_t Mnemonic;
694 uint16_t Opcode;
695 uint8_t ConvertFn;
696 uint8_t RequiredFeaturesIdx;
697 uint8_t Classes[16];
698 StringRef getMnemonic() const {
699 return StringRef(MnemonicTable + Mnemonic + 1,
700 MnemonicTable[Mnemonic]);
701 }
702 };
703
704 // Predicate for searching for an opcode.
705 struct LessOpcode {
706 bool operator()(const MatchEntry &LHS, StringRef RHS) {
707 return LHS.getMnemonic() < RHS;
708 }
709 bool operator()(StringRef LHS, const MatchEntry &RHS) {
710 return LHS < RHS.getMnemonic();
711 }
712 bool operator()(const MatchEntry &LHS, const MatchEntry &RHS) {
713 return LHS.getMnemonic() < RHS.getMnemonic();
714 }
715 };
716} // end anonymous namespace
717
718static const MatchEntry MatchTable0[] = {
719 { 1 /* atomic.fence */, WebAssembly::ATOMIC_FENCE_S, Convert__imm_95_0, AMFBS_HasAtomics, { }, },
720 { 14 /* block */, WebAssembly::BLOCK_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
721 { 20 /* br */, WebAssembly::BR_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
722 { 23 /* br_if */, WebAssembly::BR_IF_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
723 { 29 /* br_table */, WebAssembly::BR_TABLE_I32_S, Convert__BrList1_0, AMFBS_None, { MCK_BrList }, },
724 { 29 /* br_table */, WebAssembly::BR_TABLE_I64_S, Convert__BrList1_0, AMFBS_None, { MCK_BrList }, },
725 { 38 /* call */, WebAssembly::CALL_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
726 { 43 /* call_indirect */, WebAssembly::CALL_INDIRECT_S, Convert__Imm1_0__Imm1_1, AMFBS_None, { MCK_Imm, MCK_Imm }, },
727 { 57 /* call_params */, WebAssembly::CALL_PARAMS_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
728 { 69 /* call_results */, WebAssembly::CALL_RESULTS_S, Convert_NoOperands, AMFBS_None, { }, },
729 { 82 /* catch */, WebAssembly::CATCH_LEGACY_S, Convert__Imm1_0, AMFBS_HasExceptionHandling, { MCK_Imm }, },
730 { 88 /* catch_all */, WebAssembly::CATCH_ALL_LEGACY_S, Convert_NoOperands, AMFBS_HasExceptionHandling, { }, },
731 { 98 /* catchret */, WebAssembly::CATCHRET_S, Convert__imm_95_0__imm_95_0, AMFBS_HasExceptionHandling, { }, },
732 { 107 /* cleanupret */, WebAssembly::CLEANUPRET_S, Convert__imm_95_0, AMFBS_HasExceptionHandling, { }, },
733 { 118 /* compiler_fence */, WebAssembly::COMPILER_FENCE_S, Convert_NoOperands, AMFBS_HasAtomics, { }, },
734 { 133 /* data.drop */, WebAssembly::DATA_DROP_S, Convert__Imm1_0, AMFBS_HasBulkMemoryOpt, { MCK_Imm }, },
735 { 143 /* delegate */, WebAssembly::DELEGATE_S, Convert__Imm1_0, AMFBS_HasExceptionHandling, { MCK_Imm }, },
736 { 152 /* drop */, WebAssembly::DROP_EXNREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes_HasExceptionHandling, { }, },
737 { 152 /* drop */, WebAssembly::DROP_EXTERNREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
738 { 152 /* drop */, WebAssembly::DROP_FUNCREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
739 { 152 /* drop */, WebAssembly::DROP_V128_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
740 { 152 /* drop */, WebAssembly::DROP_F32_S, Convert_NoOperands, AMFBS_None, { }, },
741 { 152 /* drop */, WebAssembly::DROP_F64_S, Convert_NoOperands, AMFBS_None, { }, },
742 { 152 /* drop */, WebAssembly::DROP_I32_S, Convert_NoOperands, AMFBS_None, { }, },
743 { 152 /* drop */, WebAssembly::DROP_I64_S, Convert_NoOperands, AMFBS_None, { }, },
744 { 157 /* else */, WebAssembly::ELSE_S, Convert_NoOperands, AMFBS_None, { }, },
745 { 162 /* end */, WebAssembly::END_S, Convert_NoOperands, AMFBS_None, { }, },
746 { 166 /* end_block */, WebAssembly::END_BLOCK_S, Convert_NoOperands, AMFBS_None, { }, },
747 { 176 /* end_function */, WebAssembly::END_FUNCTION_S, Convert_NoOperands, AMFBS_None, { }, },
748 { 189 /* end_if */, WebAssembly::END_IF_S, Convert_NoOperands, AMFBS_None, { }, },
749 { 196 /* end_loop */, WebAssembly::END_LOOP_S, Convert_NoOperands, AMFBS_None, { }, },
750 { 205 /* end_try */, WebAssembly::END_TRY_S, Convert_NoOperands, AMFBS_HasExceptionHandling, { }, },
751 { 213 /* end_try_table */, WebAssembly::END_TRY_TABLE_S, Convert_NoOperands, AMFBS_HasExceptionHandling, { }, },
752 { 227 /* exnref.select */, WebAssembly::SELECT_EXNREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
753 { 241 /* externref.select */, WebAssembly::SELECT_EXTERNREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
754 { 258 /* f16x8.abs */, WebAssembly::ABS_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
755 { 268 /* f16x8.add */, WebAssembly::ADD_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
756 { 278 /* f16x8.ceil */, WebAssembly::CEIL_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
757 { 289 /* f16x8.convert_i16x8_s */, WebAssembly::sint_to_fp_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
758 { 311 /* f16x8.convert_i16x8_u */, WebAssembly::uint_to_fp_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
759 { 333 /* f16x8.div */, WebAssembly::DIV_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
760 { 343 /* f16x8.eq */, WebAssembly::EQ_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
761 { 352 /* f16x8.extract_lane */, WebAssembly::EXTRACT_LANE_F16x8_S, Convert__Imm1_0, AMFBS_HasFP16, { MCK_Imm }, },
762 { 371 /* f16x8.floor */, WebAssembly::FLOOR_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
763 { 383 /* f16x8.ge */, WebAssembly::GE_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
764 { 392 /* f16x8.gt */, WebAssembly::GT_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
765 { 401 /* f16x8.le */, WebAssembly::LE_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
766 { 410 /* f16x8.lt */, WebAssembly::LT_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
767 { 419 /* f16x8.max */, WebAssembly::MAX_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
768 { 429 /* f16x8.min */, WebAssembly::MIN_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
769 { 439 /* f16x8.mul */, WebAssembly::MUL_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
770 { 449 /* f16x8.ne */, WebAssembly::NE_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
771 { 458 /* f16x8.nearest */, WebAssembly::NEAREST_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
772 { 472 /* f16x8.neg */, WebAssembly::NEG_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
773 { 482 /* f16x8.pmax */, WebAssembly::PMAX_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
774 { 493 /* f16x8.pmin */, WebAssembly::PMIN_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
775 { 504 /* f16x8.relaxed_madd */, WebAssembly::MADD_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
776 { 523 /* f16x8.relaxed_nmadd */, WebAssembly::NMADD_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
777 { 543 /* f16x8.replace_lane */, WebAssembly::REPLACE_LANE_F16x8_S, Convert__Imm1_0, AMFBS_HasFP16, { MCK_Imm }, },
778 { 562 /* f16x8.splat */, WebAssembly::SPLAT_F16x8_S, Convert_NoOperands, AMFBS_HasFP16, { }, },
779 { 574 /* f16x8.sqrt */, WebAssembly::SQRT_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
780 { 585 /* f16x8.sub */, WebAssembly::SUB_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
781 { 595 /* f16x8.trunc */, WebAssembly::TRUNC_F16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
782 { 607 /* f32.abs */, WebAssembly::ABS_F32_S, Convert_NoOperands, AMFBS_None, { }, },
783 { 615 /* f32.add */, WebAssembly::ADD_F32_S, Convert_NoOperands, AMFBS_None, { }, },
784 { 623 /* f32.ceil */, WebAssembly::CEIL_F32_S, Convert_NoOperands, AMFBS_None, { }, },
785 { 632 /* f32.const */, WebAssembly::CONST_F32_S, Convert__FPImmf321_0, AMFBS_None, { MCK_FPImmf32 }, },
786 { 642 /* f32.convert_i32_s */, WebAssembly::F32_CONVERT_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
787 { 660 /* f32.convert_i32_u */, WebAssembly::F32_CONVERT_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
788 { 678 /* f32.convert_i64_s */, WebAssembly::F32_CONVERT_S_I64_S, Convert_NoOperands, AMFBS_None, { }, },
789 { 696 /* f32.convert_i64_u */, WebAssembly::F32_CONVERT_U_I64_S, Convert_NoOperands, AMFBS_None, { }, },
790 { 714 /* f32.copysign */, WebAssembly::COPYSIGN_F32_S, Convert_NoOperands, AMFBS_None, { }, },
791 { 727 /* f32.demote_f64 */, WebAssembly::F32_DEMOTE_F64_S, Convert_NoOperands, AMFBS_None, { }, },
792 { 742 /* f32.div */, WebAssembly::DIV_F32_S, Convert_NoOperands, AMFBS_None, { }, },
793 { 750 /* f32.eq */, WebAssembly::EQ_F32_S, Convert_NoOperands, AMFBS_None, { }, },
794 { 757 /* f32.floor */, WebAssembly::FLOOR_F32_S, Convert_NoOperands, AMFBS_None, { }, },
795 { 767 /* f32.ge */, WebAssembly::GE_F32_S, Convert_NoOperands, AMFBS_None, { }, },
796 { 774 /* f32.gt */, WebAssembly::GT_F32_S, Convert_NoOperands, AMFBS_None, { }, },
797 { 781 /* f32.le */, WebAssembly::LE_F32_S, Convert_NoOperands, AMFBS_None, { }, },
798 { 788 /* f32.load */, WebAssembly::LOAD_F32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
799 { 788 /* f32.load */, WebAssembly::LOAD_F32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
800 { 797 /* f32.load_f16 */, WebAssembly::LOAD_F16_F32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasFP16, { MCK_Imm, MCK_Imm }, },
801 { 797 /* f32.load_f16 */, WebAssembly::LOAD_F16_F32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasFP16, { MCK_Imm, MCK_Imm }, },
802 { 810 /* f32.lt */, WebAssembly::LT_F32_S, Convert_NoOperands, AMFBS_None, { }, },
803 { 817 /* f32.max */, WebAssembly::MAX_F32_S, Convert_NoOperands, AMFBS_None, { }, },
804 { 825 /* f32.min */, WebAssembly::MIN_F32_S, Convert_NoOperands, AMFBS_None, { }, },
805 { 833 /* f32.mul */, WebAssembly::MUL_F32_S, Convert_NoOperands, AMFBS_None, { }, },
806 { 841 /* f32.ne */, WebAssembly::NE_F32_S, Convert_NoOperands, AMFBS_None, { }, },
807 { 848 /* f32.nearest */, WebAssembly::NEAREST_F32_S, Convert_NoOperands, AMFBS_None, { }, },
808 { 860 /* f32.neg */, WebAssembly::NEG_F32_S, Convert_NoOperands, AMFBS_None, { }, },
809 { 868 /* f32.reinterpret_i32 */, WebAssembly::F32_REINTERPRET_I32_S, Convert_NoOperands, AMFBS_None, { }, },
810 { 888 /* f32.select */, WebAssembly::SELECT_F32_S, Convert_NoOperands, AMFBS_None, { }, },
811 { 899 /* f32.sqrt */, WebAssembly::SQRT_F32_S, Convert_NoOperands, AMFBS_None, { }, },
812 { 908 /* f32.store */, WebAssembly::STORE_F32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
813 { 908 /* f32.store */, WebAssembly::STORE_F32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
814 { 918 /* f32.store_f16 */, WebAssembly::STORE_F16_F32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasFP16, { MCK_Imm, MCK_Imm }, },
815 { 918 /* f32.store_f16 */, WebAssembly::STORE_F16_F32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasFP16, { MCK_Imm, MCK_Imm }, },
816 { 932 /* f32.sub */, WebAssembly::SUB_F32_S, Convert_NoOperands, AMFBS_None, { }, },
817 { 940 /* f32.trunc */, WebAssembly::TRUNC_F32_S, Convert_NoOperands, AMFBS_None, { }, },
818 { 950 /* f32x4.abs */, WebAssembly::ABS_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
819 { 960 /* f32x4.add */, WebAssembly::ADD_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
820 { 970 /* f32x4.ceil */, WebAssembly::CEIL_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
821 { 981 /* f32x4.convert_i32x4_s */, WebAssembly::sint_to_fp_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
822 { 1003 /* f32x4.convert_i32x4_u */, WebAssembly::uint_to_fp_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
823 { 1025 /* f32x4.demote_f64x2_zero */, WebAssembly::demote_zero_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
824 { 1049 /* f32x4.div */, WebAssembly::DIV_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
825 { 1059 /* f32x4.eq */, WebAssembly::EQ_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
826 { 1068 /* f32x4.extract_lane */, WebAssembly::EXTRACT_LANE_F32x4_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
827 { 1087 /* f32x4.floor */, WebAssembly::FLOOR_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
828 { 1099 /* f32x4.ge */, WebAssembly::GE_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
829 { 1108 /* f32x4.gt */, WebAssembly::GT_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
830 { 1117 /* f32x4.le */, WebAssembly::LE_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
831 { 1126 /* f32x4.lt */, WebAssembly::LT_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
832 { 1135 /* f32x4.max */, WebAssembly::MAX_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
833 { 1145 /* f32x4.min */, WebAssembly::MIN_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
834 { 1155 /* f32x4.mul */, WebAssembly::MUL_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
835 { 1165 /* f32x4.ne */, WebAssembly::NE_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
836 { 1174 /* f32x4.nearest */, WebAssembly::NEAREST_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
837 { 1188 /* f32x4.neg */, WebAssembly::NEG_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
838 { 1198 /* f32x4.pmax */, WebAssembly::PMAX_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
839 { 1209 /* f32x4.pmin */, WebAssembly::PMIN_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
840 { 1220 /* f32x4.relaxed_dot_bf16x8_add_f32 */, WebAssembly::RELAXED_DOT_BFLOAT_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
841 { 1253 /* f32x4.relaxed_madd */, WebAssembly::MADD_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128_HasRelaxedSIMD, { }, },
842 { 1272 /* f32x4.relaxed_max */, WebAssembly::SIMD_RELAXED_FMAX_F32x4_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
843 { 1290 /* f32x4.relaxed_min */, WebAssembly::SIMD_RELAXED_FMIN_F32x4_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
844 { 1308 /* f32x4.relaxed_nmadd */, WebAssembly::NMADD_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128_HasRelaxedSIMD, { }, },
845 { 1328 /* f32x4.replace_lane */, WebAssembly::REPLACE_LANE_F32x4_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
846 { 1347 /* f32x4.splat */, WebAssembly::SPLAT_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
847 { 1359 /* f32x4.sqrt */, WebAssembly::SQRT_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
848 { 1370 /* f32x4.sub */, WebAssembly::SUB_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
849 { 1380 /* f32x4.trunc */, WebAssembly::TRUNC_F32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
850 { 1392 /* f64.abs */, WebAssembly::ABS_F64_S, Convert_NoOperands, AMFBS_None, { }, },
851 { 1400 /* f64.add */, WebAssembly::ADD_F64_S, Convert_NoOperands, AMFBS_None, { }, },
852 { 1408 /* f64.ceil */, WebAssembly::CEIL_F64_S, Convert_NoOperands, AMFBS_None, { }, },
853 { 1417 /* f64.const */, WebAssembly::CONST_F64_S, Convert__FPImmf641_0, AMFBS_None, { MCK_FPImmf64 }, },
854 { 1427 /* f64.convert_i32_s */, WebAssembly::F64_CONVERT_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
855 { 1445 /* f64.convert_i32_u */, WebAssembly::F64_CONVERT_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
856 { 1463 /* f64.convert_i64_s */, WebAssembly::F64_CONVERT_S_I64_S, Convert_NoOperands, AMFBS_None, { }, },
857 { 1481 /* f64.convert_i64_u */, WebAssembly::F64_CONVERT_U_I64_S, Convert_NoOperands, AMFBS_None, { }, },
858 { 1499 /* f64.copysign */, WebAssembly::COPYSIGN_F64_S, Convert_NoOperands, AMFBS_None, { }, },
859 { 1512 /* f64.div */, WebAssembly::DIV_F64_S, Convert_NoOperands, AMFBS_None, { }, },
860 { 1520 /* f64.eq */, WebAssembly::EQ_F64_S, Convert_NoOperands, AMFBS_None, { }, },
861 { 1527 /* f64.floor */, WebAssembly::FLOOR_F64_S, Convert_NoOperands, AMFBS_None, { }, },
862 { 1537 /* f64.ge */, WebAssembly::GE_F64_S, Convert_NoOperands, AMFBS_None, { }, },
863 { 1544 /* f64.gt */, WebAssembly::GT_F64_S, Convert_NoOperands, AMFBS_None, { }, },
864 { 1551 /* f64.le */, WebAssembly::LE_F64_S, Convert_NoOperands, AMFBS_None, { }, },
865 { 1558 /* f64.load */, WebAssembly::LOAD_F64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
866 { 1558 /* f64.load */, WebAssembly::LOAD_F64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
867 { 1567 /* f64.lt */, WebAssembly::LT_F64_S, Convert_NoOperands, AMFBS_None, { }, },
868 { 1574 /* f64.max */, WebAssembly::MAX_F64_S, Convert_NoOperands, AMFBS_None, { }, },
869 { 1582 /* f64.min */, WebAssembly::MIN_F64_S, Convert_NoOperands, AMFBS_None, { }, },
870 { 1590 /* f64.mul */, WebAssembly::MUL_F64_S, Convert_NoOperands, AMFBS_None, { }, },
871 { 1598 /* f64.ne */, WebAssembly::NE_F64_S, Convert_NoOperands, AMFBS_None, { }, },
872 { 1605 /* f64.nearest */, WebAssembly::NEAREST_F64_S, Convert_NoOperands, AMFBS_None, { }, },
873 { 1617 /* f64.neg */, WebAssembly::NEG_F64_S, Convert_NoOperands, AMFBS_None, { }, },
874 { 1625 /* f64.promote_f32 */, WebAssembly::F64_PROMOTE_F32_S, Convert_NoOperands, AMFBS_None, { }, },
875 { 1641 /* f64.reinterpret_i64 */, WebAssembly::F64_REINTERPRET_I64_S, Convert_NoOperands, AMFBS_None, { }, },
876 { 1661 /* f64.select */, WebAssembly::SELECT_F64_S, Convert_NoOperands, AMFBS_None, { }, },
877 { 1672 /* f64.sqrt */, WebAssembly::SQRT_F64_S, Convert_NoOperands, AMFBS_None, { }, },
878 { 1681 /* f64.store */, WebAssembly::STORE_F64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
879 { 1681 /* f64.store */, WebAssembly::STORE_F64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
880 { 1691 /* f64.sub */, WebAssembly::SUB_F64_S, Convert_NoOperands, AMFBS_None, { }, },
881 { 1699 /* f64.trunc */, WebAssembly::TRUNC_F64_S, Convert_NoOperands, AMFBS_None, { }, },
882 { 1709 /* f64x2.abs */, WebAssembly::ABS_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
883 { 1719 /* f64x2.add */, WebAssembly::ADD_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
884 { 1729 /* f64x2.ceil */, WebAssembly::CEIL_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
885 { 1740 /* f64x2.convert_low_i32x4_s */, WebAssembly::convert_low_s_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
886 { 1766 /* f64x2.convert_low_i32x4_u */, WebAssembly::convert_low_u_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
887 { 1792 /* f64x2.div */, WebAssembly::DIV_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
888 { 1802 /* f64x2.eq */, WebAssembly::EQ_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
889 { 1811 /* f64x2.extract_lane */, WebAssembly::EXTRACT_LANE_F64x2_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
890 { 1830 /* f64x2.floor */, WebAssembly::FLOOR_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
891 { 1842 /* f64x2.ge */, WebAssembly::GE_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
892 { 1851 /* f64x2.gt */, WebAssembly::GT_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
893 { 1860 /* f64x2.le */, WebAssembly::LE_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
894 { 1869 /* f64x2.lt */, WebAssembly::LT_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
895 { 1878 /* f64x2.max */, WebAssembly::MAX_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
896 { 1888 /* f64x2.min */, WebAssembly::MIN_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
897 { 1898 /* f64x2.mul */, WebAssembly::MUL_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
898 { 1908 /* f64x2.ne */, WebAssembly::NE_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
899 { 1917 /* f64x2.nearest */, WebAssembly::NEAREST_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
900 { 1931 /* f64x2.neg */, WebAssembly::NEG_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
901 { 1941 /* f64x2.pmax */, WebAssembly::PMAX_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
902 { 1952 /* f64x2.pmin */, WebAssembly::PMIN_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
903 { 1963 /* f64x2.promote_low_f32x4 */, WebAssembly::promote_low_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
904 { 1987 /* f64x2.relaxed_madd */, WebAssembly::MADD_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128_HasRelaxedSIMD, { }, },
905 { 2006 /* f64x2.relaxed_max */, WebAssembly::SIMD_RELAXED_FMAX_F64x2_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
906 { 2024 /* f64x2.relaxed_min */, WebAssembly::SIMD_RELAXED_FMIN_F64x2_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
907 { 2042 /* f64x2.relaxed_nmadd */, WebAssembly::NMADD_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128_HasRelaxedSIMD, { }, },
908 { 2062 /* f64x2.replace_lane */, WebAssembly::REPLACE_LANE_F64x2_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
909 { 2081 /* f64x2.splat */, WebAssembly::SPLAT_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
910 { 2093 /* f64x2.sqrt */, WebAssembly::SQRT_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
911 { 2104 /* f64x2.sub */, WebAssembly::SUB_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
912 { 2114 /* f64x2.trunc */, WebAssembly::TRUNC_F64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
913 { 2126 /* funcref.select */, WebAssembly::SELECT_FUNCREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
914 { 2141 /* global.get */, WebAssembly::GLOBAL_GET_EXNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes_HasExceptionHandling, { MCK_Imm }, },
915 { 2141 /* global.get */, WebAssembly::GLOBAL_GET_EXTERNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
916 { 2141 /* global.get */, WebAssembly::GLOBAL_GET_FUNCREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
917 { 2141 /* global.get */, WebAssembly::GLOBAL_GET_V128_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
918 { 2141 /* global.get */, WebAssembly::GLOBAL_GET_F32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
919 { 2141 /* global.get */, WebAssembly::GLOBAL_GET_F64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
920 { 2141 /* global.get */, WebAssembly::GLOBAL_GET_I32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
921 { 2141 /* global.get */, WebAssembly::GLOBAL_GET_I64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
922 { 2152 /* global.set */, WebAssembly::GLOBAL_SET_EXNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes_HasExceptionHandling, { MCK_Imm }, },
923 { 2152 /* global.set */, WebAssembly::GLOBAL_SET_EXTERNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
924 { 2152 /* global.set */, WebAssembly::GLOBAL_SET_FUNCREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
925 { 2152 /* global.set */, WebAssembly::GLOBAL_SET_V128_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
926 { 2152 /* global.set */, WebAssembly::GLOBAL_SET_F32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
927 { 2152 /* global.set */, WebAssembly::GLOBAL_SET_F64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
928 { 2152 /* global.set */, WebAssembly::GLOBAL_SET_I32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
929 { 2152 /* global.set */, WebAssembly::GLOBAL_SET_I64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
930 { 2163 /* i16x8.abs */, WebAssembly::ABS_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
931 { 2173 /* i16x8.add */, WebAssembly::ADD_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
932 { 2183 /* i16x8.add_sat_s */, WebAssembly::ADD_SAT_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
933 { 2199 /* i16x8.add_sat_u */, WebAssembly::ADD_SAT_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
934 { 2215 /* i16x8.all_true */, WebAssembly::ALLTRUE_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
935 { 2230 /* i16x8.avgr_u */, WebAssembly::AVGR_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
936 { 2243 /* i16x8.bitmask */, WebAssembly::BITMASK_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
937 { 2257 /* i16x8.eq */, WebAssembly::EQ_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
938 { 2266 /* i16x8.extadd_pairwise_i8x16_s */, WebAssembly::int_wasm_extadd_pairwise_signed_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
939 { 2296 /* i16x8.extadd_pairwise_i8x16_u */, WebAssembly::int_wasm_extadd_pairwise_unsigned_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
940 { 2326 /* i16x8.extend_high_i8x16_s */, WebAssembly::extend_high_s_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
941 { 2352 /* i16x8.extend_high_i8x16_u */, WebAssembly::extend_high_u_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
942 { 2378 /* i16x8.extend_low_i8x16_s */, WebAssembly::extend_low_s_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
943 { 2403 /* i16x8.extend_low_i8x16_u */, WebAssembly::extend_low_u_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
944 { 2428 /* i16x8.extmul_high_i8x16_s */, WebAssembly::EXTMUL_HIGH_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
945 { 2454 /* i16x8.extmul_high_i8x16_u */, WebAssembly::EXTMUL_HIGH_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
946 { 2480 /* i16x8.extmul_low_i8x16_s */, WebAssembly::EXTMUL_LOW_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
947 { 2505 /* i16x8.extmul_low_i8x16_u */, WebAssembly::EXTMUL_LOW_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
948 { 2530 /* i16x8.extract_lane_s */, WebAssembly::EXTRACT_LANE_I16x8_s_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
949 { 2551 /* i16x8.extract_lane_u */, WebAssembly::EXTRACT_LANE_I16x8_u_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
950 { 2572 /* i16x8.ge_s */, WebAssembly::GE_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
951 { 2583 /* i16x8.ge_u */, WebAssembly::GE_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
952 { 2594 /* i16x8.gt_s */, WebAssembly::GT_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
953 { 2605 /* i16x8.gt_u */, WebAssembly::GT_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
954 { 2616 /* i16x8.le_s */, WebAssembly::LE_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
955 { 2627 /* i16x8.le_u */, WebAssembly::LE_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
956 { 2638 /* i16x8.load8x8_s */, WebAssembly::LOAD_EXTEND_S_I16x8_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
957 { 2638 /* i16x8.load8x8_s */, WebAssembly::LOAD_EXTEND_S_I16x8_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
958 { 2654 /* i16x8.load8x8_u */, WebAssembly::LOAD_EXTEND_U_I16x8_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
959 { 2654 /* i16x8.load8x8_u */, WebAssembly::LOAD_EXTEND_U_I16x8_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
960 { 2670 /* i16x8.lt_s */, WebAssembly::LT_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
961 { 2681 /* i16x8.lt_u */, WebAssembly::LT_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
962 { 2692 /* i16x8.max_s */, WebAssembly::MAX_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
963 { 2704 /* i16x8.max_u */, WebAssembly::MAX_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
964 { 2716 /* i16x8.min_s */, WebAssembly::MIN_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
965 { 2728 /* i16x8.min_u */, WebAssembly::MIN_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
966 { 2740 /* i16x8.mul */, WebAssembly::MUL_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
967 { 2750 /* i16x8.narrow_i32x4_s */, WebAssembly::NARROW_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
968 { 2771 /* i16x8.narrow_i32x4_u */, WebAssembly::NARROW_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
969 { 2792 /* i16x8.ne */, WebAssembly::NE_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
970 { 2801 /* i16x8.neg */, WebAssembly::NEG_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
971 { 2811 /* i16x8.q15mulr_sat_s */, WebAssembly::Q15MULR_SAT_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
972 { 2831 /* i16x8.relaxed_dot_i8x16_i7x16_s */, WebAssembly::RELAXED_DOT_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
973 { 2863 /* i16x8.relaxed_laneselect */, WebAssembly::LANESELECT_I16x8_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
974 { 2888 /* i16x8.relaxed_q15mulr_s */, WebAssembly::RELAXED_Q15MULR_S_I16x8_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
975 { 2912 /* i16x8.replace_lane */, WebAssembly::REPLACE_LANE_I16x8_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
976 { 2931 /* i16x8.shl */, WebAssembly::SHL_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
977 { 2941 /* i16x8.shr_s */, WebAssembly::SHR_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
978 { 2953 /* i16x8.shr_u */, WebAssembly::SHR_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
979 { 2965 /* i16x8.splat */, WebAssembly::SPLAT_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
980 { 2977 /* i16x8.sub */, WebAssembly::SUB_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
981 { 2987 /* i16x8.sub_sat_s */, WebAssembly::SUB_SAT_S_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
982 { 3003 /* i16x8.sub_sat_u */, WebAssembly::SUB_SAT_U_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
983 { 3019 /* i16x8.trunc_sat_f16x8_s */, WebAssembly::fp_to_sint_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
984 { 3043 /* i16x8.trunc_sat_f16x8_u */, WebAssembly::fp_to_uint_I16x8_S, Convert_NoOperands, AMFBS_HasSIMD128_HasFP16, { }, },
985 { 3067 /* i32.add */, WebAssembly::ADD_I32_S, Convert_NoOperands, AMFBS_None, { }, },
986 { 3075 /* i32.and */, WebAssembly::AND_I32_S, Convert_NoOperands, AMFBS_None, { }, },
987 { 3083 /* i32.atomic.load */, WebAssembly::ATOMIC_LOAD_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
988 { 3083 /* i32.atomic.load */, WebAssembly::ATOMIC_LOAD_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
989 { 3099 /* i32.atomic.load16_u */, WebAssembly::ATOMIC_LOAD16_U_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
990 { 3099 /* i32.atomic.load16_u */, WebAssembly::ATOMIC_LOAD16_U_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
991 { 3119 /* i32.atomic.load8_u */, WebAssembly::ATOMIC_LOAD8_U_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
992 { 3119 /* i32.atomic.load8_u */, WebAssembly::ATOMIC_LOAD8_U_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
993 { 3138 /* i32.atomic.rmw.add */, WebAssembly::ATOMIC_RMW_ADD_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
994 { 3138 /* i32.atomic.rmw.add */, WebAssembly::ATOMIC_RMW_ADD_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
995 { 3157 /* i32.atomic.rmw.and */, WebAssembly::ATOMIC_RMW_AND_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
996 { 3157 /* i32.atomic.rmw.and */, WebAssembly::ATOMIC_RMW_AND_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
997 { 3176 /* i32.atomic.rmw.cmpxchg */, WebAssembly::ATOMIC_RMW_CMPXCHG_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
998 { 3176 /* i32.atomic.rmw.cmpxchg */, WebAssembly::ATOMIC_RMW_CMPXCHG_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
999 { 3199 /* i32.atomic.rmw.or */, WebAssembly::ATOMIC_RMW_OR_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1000 { 3199 /* i32.atomic.rmw.or */, WebAssembly::ATOMIC_RMW_OR_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1001 { 3217 /* i32.atomic.rmw.sub */, WebAssembly::ATOMIC_RMW_SUB_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1002 { 3217 /* i32.atomic.rmw.sub */, WebAssembly::ATOMIC_RMW_SUB_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1003 { 3236 /* i32.atomic.rmw.xchg */, WebAssembly::ATOMIC_RMW_XCHG_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1004 { 3236 /* i32.atomic.rmw.xchg */, WebAssembly::ATOMIC_RMW_XCHG_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1005 { 3256 /* i32.atomic.rmw.xor */, WebAssembly::ATOMIC_RMW_XOR_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1006 { 3256 /* i32.atomic.rmw.xor */, WebAssembly::ATOMIC_RMW_XOR_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1007 { 3275 /* i32.atomic.rmw16.add_u */, WebAssembly::ATOMIC_RMW16_U_ADD_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1008 { 3275 /* i32.atomic.rmw16.add_u */, WebAssembly::ATOMIC_RMW16_U_ADD_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1009 { 3298 /* i32.atomic.rmw16.and_u */, WebAssembly::ATOMIC_RMW16_U_AND_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1010 { 3298 /* i32.atomic.rmw16.and_u */, WebAssembly::ATOMIC_RMW16_U_AND_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1011 { 3321 /* i32.atomic.rmw16.cmpxchg_u */, WebAssembly::ATOMIC_RMW16_U_CMPXCHG_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1012 { 3321 /* i32.atomic.rmw16.cmpxchg_u */, WebAssembly::ATOMIC_RMW16_U_CMPXCHG_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1013 { 3348 /* i32.atomic.rmw16.or_u */, WebAssembly::ATOMIC_RMW16_U_OR_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1014 { 3348 /* i32.atomic.rmw16.or_u */, WebAssembly::ATOMIC_RMW16_U_OR_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1015 { 3370 /* i32.atomic.rmw16.sub_u */, WebAssembly::ATOMIC_RMW16_U_SUB_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1016 { 3370 /* i32.atomic.rmw16.sub_u */, WebAssembly::ATOMIC_RMW16_U_SUB_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1017 { 3393 /* i32.atomic.rmw16.xchg_u */, WebAssembly::ATOMIC_RMW16_U_XCHG_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1018 { 3393 /* i32.atomic.rmw16.xchg_u */, WebAssembly::ATOMIC_RMW16_U_XCHG_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1019 { 3417 /* i32.atomic.rmw16.xor_u */, WebAssembly::ATOMIC_RMW16_U_XOR_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1020 { 3417 /* i32.atomic.rmw16.xor_u */, WebAssembly::ATOMIC_RMW16_U_XOR_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1021 { 3440 /* i32.atomic.rmw8.add_u */, WebAssembly::ATOMIC_RMW8_U_ADD_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1022 { 3440 /* i32.atomic.rmw8.add_u */, WebAssembly::ATOMIC_RMW8_U_ADD_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1023 { 3462 /* i32.atomic.rmw8.and_u */, WebAssembly::ATOMIC_RMW8_U_AND_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1024 { 3462 /* i32.atomic.rmw8.and_u */, WebAssembly::ATOMIC_RMW8_U_AND_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1025 { 3484 /* i32.atomic.rmw8.cmpxchg_u */, WebAssembly::ATOMIC_RMW8_U_CMPXCHG_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1026 { 3484 /* i32.atomic.rmw8.cmpxchg_u */, WebAssembly::ATOMIC_RMW8_U_CMPXCHG_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1027 { 3510 /* i32.atomic.rmw8.or_u */, WebAssembly::ATOMIC_RMW8_U_OR_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1028 { 3510 /* i32.atomic.rmw8.or_u */, WebAssembly::ATOMIC_RMW8_U_OR_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1029 { 3531 /* i32.atomic.rmw8.sub_u */, WebAssembly::ATOMIC_RMW8_U_SUB_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1030 { 3531 /* i32.atomic.rmw8.sub_u */, WebAssembly::ATOMIC_RMW8_U_SUB_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1031 { 3553 /* i32.atomic.rmw8.xchg_u */, WebAssembly::ATOMIC_RMW8_U_XCHG_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1032 { 3553 /* i32.atomic.rmw8.xchg_u */, WebAssembly::ATOMIC_RMW8_U_XCHG_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1033 { 3576 /* i32.atomic.rmw8.xor_u */, WebAssembly::ATOMIC_RMW8_U_XOR_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1034 { 3576 /* i32.atomic.rmw8.xor_u */, WebAssembly::ATOMIC_RMW8_U_XOR_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1035 { 3598 /* i32.atomic.store */, WebAssembly::ATOMIC_STORE_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1036 { 3598 /* i32.atomic.store */, WebAssembly::ATOMIC_STORE_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1037 { 3615 /* i32.atomic.store16 */, WebAssembly::ATOMIC_STORE16_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1038 { 3615 /* i32.atomic.store16 */, WebAssembly::ATOMIC_STORE16_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1039 { 3634 /* i32.atomic.store8 */, WebAssembly::ATOMIC_STORE8_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1040 { 3634 /* i32.atomic.store8 */, WebAssembly::ATOMIC_STORE8_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1041 { 3652 /* i32.clz */, WebAssembly::CLZ_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1042 { 3660 /* i32.const */, WebAssembly::CONST_I32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1043 { 3670 /* i32.ctz */, WebAssembly::CTZ_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1044 { 3678 /* i32.div_s */, WebAssembly::DIV_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1045 { 3688 /* i32.div_u */, WebAssembly::DIV_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1046 { 3698 /* i32.eq */, WebAssembly::EQ_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1047 { 3705 /* i32.eqz */, WebAssembly::EQZ_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1048 { 3713 /* i32.extend16_s */, WebAssembly::I32_EXTEND16_S_I32_S, Convert_NoOperands, AMFBS_HasSignExt, { }, },
1049 { 3728 /* i32.extend8_s */, WebAssembly::I32_EXTEND8_S_I32_S, Convert_NoOperands, AMFBS_HasSignExt, { }, },
1050 { 3742 /* i32.ge_s */, WebAssembly::GE_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1051 { 3751 /* i32.ge_u */, WebAssembly::GE_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1052 { 3760 /* i32.gt_s */, WebAssembly::GT_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1053 { 3769 /* i32.gt_u */, WebAssembly::GT_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1054 { 3778 /* i32.le_s */, WebAssembly::LE_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1055 { 3787 /* i32.le_u */, WebAssembly::LE_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1056 { 3796 /* i32.load */, WebAssembly::LOAD_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1057 { 3796 /* i32.load */, WebAssembly::LOAD_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1058 { 3805 /* i32.load16_s */, WebAssembly::LOAD16_S_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1059 { 3805 /* i32.load16_s */, WebAssembly::LOAD16_S_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1060 { 3818 /* i32.load16_u */, WebAssembly::LOAD16_U_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1061 { 3818 /* i32.load16_u */, WebAssembly::LOAD16_U_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1062 { 3831 /* i32.load8_s */, WebAssembly::LOAD8_S_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1063 { 3831 /* i32.load8_s */, WebAssembly::LOAD8_S_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1064 { 3843 /* i32.load8_u */, WebAssembly::LOAD8_U_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1065 { 3843 /* i32.load8_u */, WebAssembly::LOAD8_U_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1066 { 3855 /* i32.lt_s */, WebAssembly::LT_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1067 { 3864 /* i32.lt_u */, WebAssembly::LT_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1068 { 3873 /* i32.mul */, WebAssembly::MUL_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1069 { 3881 /* i32.ne */, WebAssembly::NE_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1070 { 3888 /* i32.or */, WebAssembly::OR_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1071 { 3895 /* i32.popcnt */, WebAssembly::POPCNT_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1072 { 3906 /* i32.reinterpret_f32 */, WebAssembly::I32_REINTERPRET_F32_S, Convert_NoOperands, AMFBS_None, { }, },
1073 { 3926 /* i32.rem_s */, WebAssembly::REM_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1074 { 3936 /* i32.rem_u */, WebAssembly::REM_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1075 { 3946 /* i32.rotl */, WebAssembly::ROTL_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1076 { 3955 /* i32.rotr */, WebAssembly::ROTR_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1077 { 3964 /* i32.select */, WebAssembly::SELECT_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1078 { 3975 /* i32.shl */, WebAssembly::SHL_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1079 { 3983 /* i32.shr_s */, WebAssembly::SHR_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1080 { 3993 /* i32.shr_u */, WebAssembly::SHR_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1081 { 4003 /* i32.store */, WebAssembly::STORE_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1082 { 4003 /* i32.store */, WebAssembly::STORE_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1083 { 4013 /* i32.store16 */, WebAssembly::STORE16_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1084 { 4013 /* i32.store16 */, WebAssembly::STORE16_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1085 { 4025 /* i32.store8 */, WebAssembly::STORE8_I32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1086 { 4025 /* i32.store8 */, WebAssembly::STORE8_I32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1087 { 4036 /* i32.sub */, WebAssembly::SUB_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1088 { 4044 /* i32.trunc_f32_s */, WebAssembly::I32_TRUNC_S_F32_S, Convert_NoOperands, AMFBS_None, { }, },
1089 { 4060 /* i32.trunc_f32_u */, WebAssembly::I32_TRUNC_U_F32_S, Convert_NoOperands, AMFBS_None, { }, },
1090 { 4076 /* i32.trunc_f64_s */, WebAssembly::I32_TRUNC_S_F64_S, Convert_NoOperands, AMFBS_None, { }, },
1091 { 4092 /* i32.trunc_f64_u */, WebAssembly::I32_TRUNC_U_F64_S, Convert_NoOperands, AMFBS_None, { }, },
1092 { 4108 /* i32.trunc_sat_f32_s */, WebAssembly::I32_TRUNC_S_SAT_F32_S, Convert_NoOperands, AMFBS_HasNontrappingFPToInt, { }, },
1093 { 4128 /* i32.trunc_sat_f32_u */, WebAssembly::I32_TRUNC_U_SAT_F32_S, Convert_NoOperands, AMFBS_HasNontrappingFPToInt, { }, },
1094 { 4148 /* i32.trunc_sat_f64_s */, WebAssembly::I32_TRUNC_S_SAT_F64_S, Convert_NoOperands, AMFBS_HasNontrappingFPToInt, { }, },
1095 { 4168 /* i32.trunc_sat_f64_u */, WebAssembly::I32_TRUNC_U_SAT_F64_S, Convert_NoOperands, AMFBS_HasNontrappingFPToInt, { }, },
1096 { 4188 /* i32.wrap_i64 */, WebAssembly::I32_WRAP_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1097 { 4201 /* i32.xor */, WebAssembly::XOR_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1098 { 4209 /* i32x4.abs */, WebAssembly::ABS_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1099 { 4219 /* i32x4.add */, WebAssembly::ADD_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1100 { 4229 /* i32x4.all_true */, WebAssembly::ALLTRUE_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1101 { 4244 /* i32x4.bitmask */, WebAssembly::BITMASK_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1102 { 4258 /* i32x4.dot_i16x8_s */, WebAssembly::DOT_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1103 { 4276 /* i32x4.eq */, WebAssembly::EQ_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1104 { 4285 /* i32x4.extadd_pairwise_i16x8_s */, WebAssembly::int_wasm_extadd_pairwise_signed_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1105 { 4315 /* i32x4.extadd_pairwise_i16x8_u */, WebAssembly::int_wasm_extadd_pairwise_unsigned_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1106 { 4345 /* i32x4.extend_high_i16x8_s */, WebAssembly::extend_high_s_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1107 { 4371 /* i32x4.extend_high_i16x8_u */, WebAssembly::extend_high_u_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1108 { 4397 /* i32x4.extend_low_i16x8_s */, WebAssembly::extend_low_s_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1109 { 4422 /* i32x4.extend_low_i16x8_u */, WebAssembly::extend_low_u_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1110 { 4447 /* i32x4.extmul_high_i16x8_s */, WebAssembly::EXTMUL_HIGH_S_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1111 { 4473 /* i32x4.extmul_high_i16x8_u */, WebAssembly::EXTMUL_HIGH_U_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1112 { 4499 /* i32x4.extmul_low_i16x8_s */, WebAssembly::EXTMUL_LOW_S_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1113 { 4524 /* i32x4.extmul_low_i16x8_u */, WebAssembly::EXTMUL_LOW_U_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1114 { 4549 /* i32x4.extract_lane */, WebAssembly::EXTRACT_LANE_I32x4_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1115 { 4568 /* i32x4.ge_s */, WebAssembly::GE_S_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1116 { 4579 /* i32x4.ge_u */, WebAssembly::GE_U_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1117 { 4590 /* i32x4.gt_s */, WebAssembly::GT_S_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1118 { 4601 /* i32x4.gt_u */, WebAssembly::GT_U_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1119 { 4612 /* i32x4.le_s */, WebAssembly::LE_S_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1120 { 4623 /* i32x4.le_u */, WebAssembly::LE_U_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1121 { 4634 /* i32x4.load16x4_s */, WebAssembly::LOAD_EXTEND_S_I32x4_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1122 { 4634 /* i32x4.load16x4_s */, WebAssembly::LOAD_EXTEND_S_I32x4_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1123 { 4651 /* i32x4.load16x4_u */, WebAssembly::LOAD_EXTEND_U_I32x4_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1124 { 4651 /* i32x4.load16x4_u */, WebAssembly::LOAD_EXTEND_U_I32x4_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1125 { 4668 /* i32x4.lt_s */, WebAssembly::LT_S_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1126 { 4679 /* i32x4.lt_u */, WebAssembly::LT_U_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1127 { 4690 /* i32x4.max_s */, WebAssembly::MAX_S_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1128 { 4702 /* i32x4.max_u */, WebAssembly::MAX_U_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1129 { 4714 /* i32x4.min_s */, WebAssembly::MIN_S_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1130 { 4726 /* i32x4.min_u */, WebAssembly::MIN_U_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1131 { 4738 /* i32x4.mul */, WebAssembly::MUL_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1132 { 4748 /* i32x4.ne */, WebAssembly::NE_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1133 { 4757 /* i32x4.neg */, WebAssembly::NEG_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1134 { 4767 /* i32x4.relaxed_dot_i8x16_i7x16_add_s */, WebAssembly::RELAXED_DOT_ADD_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
1135 { 4803 /* i32x4.relaxed_laneselect */, WebAssembly::LANESELECT_I32x4_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
1136 { 4828 /* i32x4.relaxed_trunc_f32x4_s */, WebAssembly::int_wasm_relaxed_trunc_signed_I32x4_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
1137 { 4856 /* i32x4.relaxed_trunc_f32x4_u */, WebAssembly::int_wasm_relaxed_trunc_unsigned_I32x4_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
1138 { 4884 /* i32x4.relaxed_trunc_f64x2_s_zero */, WebAssembly::int_wasm_relaxed_trunc_signed_zero_I32x4_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
1139 { 4917 /* i32x4.relaxed_trunc_f64x2_u_zero */, WebAssembly::int_wasm_relaxed_trunc_unsigned_zero_I32x4_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
1140 { 4950 /* i32x4.replace_lane */, WebAssembly::REPLACE_LANE_I32x4_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1141 { 4969 /* i32x4.shl */, WebAssembly::SHL_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1142 { 4979 /* i32x4.shr_s */, WebAssembly::SHR_S_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1143 { 4991 /* i32x4.shr_u */, WebAssembly::SHR_U_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1144 { 5003 /* i32x4.splat */, WebAssembly::SPLAT_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1145 { 5015 /* i32x4.sub */, WebAssembly::SUB_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1146 { 5025 /* i32x4.trunc_sat_f32x4_s */, WebAssembly::fp_to_sint_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1147 { 5049 /* i32x4.trunc_sat_f32x4_u */, WebAssembly::fp_to_uint_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1148 { 5073 /* i32x4.trunc_sat_f64x2_s_zero */, WebAssembly::trunc_sat_zero_s_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1149 { 5102 /* i32x4.trunc_sat_f64x2_u_zero */, WebAssembly::trunc_sat_zero_u_I32x4_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1150 { 5131 /* i64.add */, WebAssembly::ADD_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1151 { 5139 /* i64.add128 */, WebAssembly::I64_ADD128_S, Convert_NoOperands, AMFBS_HasWideArithmetic, { }, },
1152 { 5150 /* i64.and */, WebAssembly::AND_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1153 { 5158 /* i64.atomic.load */, WebAssembly::ATOMIC_LOAD_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1154 { 5158 /* i64.atomic.load */, WebAssembly::ATOMIC_LOAD_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1155 { 5174 /* i64.atomic.load16_u */, WebAssembly::ATOMIC_LOAD16_U_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1156 { 5174 /* i64.atomic.load16_u */, WebAssembly::ATOMIC_LOAD16_U_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1157 { 5194 /* i64.atomic.load32_u */, WebAssembly::ATOMIC_LOAD32_U_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1158 { 5194 /* i64.atomic.load32_u */, WebAssembly::ATOMIC_LOAD32_U_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1159 { 5214 /* i64.atomic.load8_u */, WebAssembly::ATOMIC_LOAD8_U_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1160 { 5214 /* i64.atomic.load8_u */, WebAssembly::ATOMIC_LOAD8_U_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1161 { 5233 /* i64.atomic.rmw.add */, WebAssembly::ATOMIC_RMW_ADD_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1162 { 5233 /* i64.atomic.rmw.add */, WebAssembly::ATOMIC_RMW_ADD_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1163 { 5252 /* i64.atomic.rmw.and */, WebAssembly::ATOMIC_RMW_AND_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1164 { 5252 /* i64.atomic.rmw.and */, WebAssembly::ATOMIC_RMW_AND_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1165 { 5271 /* i64.atomic.rmw.cmpxchg */, WebAssembly::ATOMIC_RMW_CMPXCHG_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1166 { 5271 /* i64.atomic.rmw.cmpxchg */, WebAssembly::ATOMIC_RMW_CMPXCHG_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1167 { 5294 /* i64.atomic.rmw.or */, WebAssembly::ATOMIC_RMW_OR_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1168 { 5294 /* i64.atomic.rmw.or */, WebAssembly::ATOMIC_RMW_OR_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1169 { 5312 /* i64.atomic.rmw.sub */, WebAssembly::ATOMIC_RMW_SUB_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1170 { 5312 /* i64.atomic.rmw.sub */, WebAssembly::ATOMIC_RMW_SUB_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1171 { 5331 /* i64.atomic.rmw.xchg */, WebAssembly::ATOMIC_RMW_XCHG_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1172 { 5331 /* i64.atomic.rmw.xchg */, WebAssembly::ATOMIC_RMW_XCHG_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1173 { 5351 /* i64.atomic.rmw.xor */, WebAssembly::ATOMIC_RMW_XOR_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1174 { 5351 /* i64.atomic.rmw.xor */, WebAssembly::ATOMIC_RMW_XOR_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1175 { 5370 /* i64.atomic.rmw16.add_u */, WebAssembly::ATOMIC_RMW16_U_ADD_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1176 { 5370 /* i64.atomic.rmw16.add_u */, WebAssembly::ATOMIC_RMW16_U_ADD_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1177 { 5393 /* i64.atomic.rmw16.and_u */, WebAssembly::ATOMIC_RMW16_U_AND_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1178 { 5393 /* i64.atomic.rmw16.and_u */, WebAssembly::ATOMIC_RMW16_U_AND_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1179 { 5416 /* i64.atomic.rmw16.cmpxchg_u */, WebAssembly::ATOMIC_RMW16_U_CMPXCHG_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1180 { 5416 /* i64.atomic.rmw16.cmpxchg_u */, WebAssembly::ATOMIC_RMW16_U_CMPXCHG_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1181 { 5443 /* i64.atomic.rmw16.or_u */, WebAssembly::ATOMIC_RMW16_U_OR_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1182 { 5443 /* i64.atomic.rmw16.or_u */, WebAssembly::ATOMIC_RMW16_U_OR_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1183 { 5465 /* i64.atomic.rmw16.sub_u */, WebAssembly::ATOMIC_RMW16_U_SUB_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1184 { 5465 /* i64.atomic.rmw16.sub_u */, WebAssembly::ATOMIC_RMW16_U_SUB_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1185 { 5488 /* i64.atomic.rmw16.xchg_u */, WebAssembly::ATOMIC_RMW16_U_XCHG_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1186 { 5488 /* i64.atomic.rmw16.xchg_u */, WebAssembly::ATOMIC_RMW16_U_XCHG_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1187 { 5512 /* i64.atomic.rmw16.xor_u */, WebAssembly::ATOMIC_RMW16_U_XOR_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1188 { 5512 /* i64.atomic.rmw16.xor_u */, WebAssembly::ATOMIC_RMW16_U_XOR_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1189 { 5535 /* i64.atomic.rmw32.add_u */, WebAssembly::ATOMIC_RMW32_U_ADD_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1190 { 5535 /* i64.atomic.rmw32.add_u */, WebAssembly::ATOMIC_RMW32_U_ADD_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1191 { 5558 /* i64.atomic.rmw32.and_u */, WebAssembly::ATOMIC_RMW32_U_AND_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1192 { 5558 /* i64.atomic.rmw32.and_u */, WebAssembly::ATOMIC_RMW32_U_AND_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1193 { 5581 /* i64.atomic.rmw32.cmpxchg_u */, WebAssembly::ATOMIC_RMW32_U_CMPXCHG_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1194 { 5581 /* i64.atomic.rmw32.cmpxchg_u */, WebAssembly::ATOMIC_RMW32_U_CMPXCHG_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1195 { 5608 /* i64.atomic.rmw32.or_u */, WebAssembly::ATOMIC_RMW32_U_OR_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1196 { 5608 /* i64.atomic.rmw32.or_u */, WebAssembly::ATOMIC_RMW32_U_OR_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1197 { 5630 /* i64.atomic.rmw32.sub_u */, WebAssembly::ATOMIC_RMW32_U_SUB_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1198 { 5630 /* i64.atomic.rmw32.sub_u */, WebAssembly::ATOMIC_RMW32_U_SUB_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1199 { 5653 /* i64.atomic.rmw32.xchg_u */, WebAssembly::ATOMIC_RMW32_U_XCHG_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1200 { 5653 /* i64.atomic.rmw32.xchg_u */, WebAssembly::ATOMIC_RMW32_U_XCHG_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1201 { 5677 /* i64.atomic.rmw32.xor_u */, WebAssembly::ATOMIC_RMW32_U_XOR_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1202 { 5677 /* i64.atomic.rmw32.xor_u */, WebAssembly::ATOMIC_RMW32_U_XOR_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1203 { 5700 /* i64.atomic.rmw8.add_u */, WebAssembly::ATOMIC_RMW8_U_ADD_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1204 { 5700 /* i64.atomic.rmw8.add_u */, WebAssembly::ATOMIC_RMW8_U_ADD_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1205 { 5722 /* i64.atomic.rmw8.and_u */, WebAssembly::ATOMIC_RMW8_U_AND_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1206 { 5722 /* i64.atomic.rmw8.and_u */, WebAssembly::ATOMIC_RMW8_U_AND_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1207 { 5744 /* i64.atomic.rmw8.cmpxchg_u */, WebAssembly::ATOMIC_RMW8_U_CMPXCHG_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1208 { 5744 /* i64.atomic.rmw8.cmpxchg_u */, WebAssembly::ATOMIC_RMW8_U_CMPXCHG_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1209 { 5770 /* i64.atomic.rmw8.or_u */, WebAssembly::ATOMIC_RMW8_U_OR_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1210 { 5770 /* i64.atomic.rmw8.or_u */, WebAssembly::ATOMIC_RMW8_U_OR_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1211 { 5791 /* i64.atomic.rmw8.sub_u */, WebAssembly::ATOMIC_RMW8_U_SUB_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1212 { 5791 /* i64.atomic.rmw8.sub_u */, WebAssembly::ATOMIC_RMW8_U_SUB_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1213 { 5813 /* i64.atomic.rmw8.xchg_u */, WebAssembly::ATOMIC_RMW8_U_XCHG_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1214 { 5813 /* i64.atomic.rmw8.xchg_u */, WebAssembly::ATOMIC_RMW8_U_XCHG_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1215 { 5836 /* i64.atomic.rmw8.xor_u */, WebAssembly::ATOMIC_RMW8_U_XOR_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1216 { 5836 /* i64.atomic.rmw8.xor_u */, WebAssembly::ATOMIC_RMW8_U_XOR_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1217 { 5858 /* i64.atomic.store */, WebAssembly::ATOMIC_STORE_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1218 { 5858 /* i64.atomic.store */, WebAssembly::ATOMIC_STORE_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1219 { 5875 /* i64.atomic.store16 */, WebAssembly::ATOMIC_STORE16_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1220 { 5875 /* i64.atomic.store16 */, WebAssembly::ATOMIC_STORE16_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1221 { 5894 /* i64.atomic.store32 */, WebAssembly::ATOMIC_STORE32_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1222 { 5894 /* i64.atomic.store32 */, WebAssembly::ATOMIC_STORE32_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1223 { 5913 /* i64.atomic.store8 */, WebAssembly::ATOMIC_STORE8_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1224 { 5913 /* i64.atomic.store8 */, WebAssembly::ATOMIC_STORE8_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1225 { 5931 /* i64.clz */, WebAssembly::CLZ_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1226 { 5939 /* i64.const */, WebAssembly::CONST_I64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1227 { 5949 /* i64.ctz */, WebAssembly::CTZ_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1228 { 5957 /* i64.div_s */, WebAssembly::DIV_S_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1229 { 5967 /* i64.div_u */, WebAssembly::DIV_U_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1230 { 5977 /* i64.eq */, WebAssembly::EQ_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1231 { 5984 /* i64.eqz */, WebAssembly::EQZ_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1232 { 5992 /* i64.extend16_s */, WebAssembly::I64_EXTEND16_S_I64_S, Convert_NoOperands, AMFBS_HasSignExt, { }, },
1233 { 6007 /* i64.extend32_s */, WebAssembly::I64_EXTEND32_S_I64_S, Convert_NoOperands, AMFBS_HasSignExt, { }, },
1234 { 6022 /* i64.extend8_s */, WebAssembly::I64_EXTEND8_S_I64_S, Convert_NoOperands, AMFBS_HasSignExt, { }, },
1235 { 6036 /* i64.extend_i32_s */, WebAssembly::I64_EXTEND_S_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1236 { 6053 /* i64.extend_i32_u */, WebAssembly::I64_EXTEND_U_I32_S, Convert_NoOperands, AMFBS_None, { }, },
1237 { 6070 /* i64.ge_s */, WebAssembly::GE_S_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1238 { 6079 /* i64.ge_u */, WebAssembly::GE_U_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1239 { 6088 /* i64.gt_s */, WebAssembly::GT_S_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1240 { 6097 /* i64.gt_u */, WebAssembly::GT_U_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1241 { 6106 /* i64.le_s */, WebAssembly::LE_S_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1242 { 6115 /* i64.le_u */, WebAssembly::LE_U_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1243 { 6124 /* i64.load */, WebAssembly::LOAD_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1244 { 6124 /* i64.load */, WebAssembly::LOAD_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1245 { 6133 /* i64.load16_s */, WebAssembly::LOAD16_S_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1246 { 6133 /* i64.load16_s */, WebAssembly::LOAD16_S_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1247 { 6146 /* i64.load16_u */, WebAssembly::LOAD16_U_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1248 { 6146 /* i64.load16_u */, WebAssembly::LOAD16_U_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1249 { 6159 /* i64.load32_s */, WebAssembly::LOAD32_S_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1250 { 6159 /* i64.load32_s */, WebAssembly::LOAD32_S_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1251 { 6172 /* i64.load32_u */, WebAssembly::LOAD32_U_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1252 { 6172 /* i64.load32_u */, WebAssembly::LOAD32_U_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1253 { 6185 /* i64.load8_s */, WebAssembly::LOAD8_S_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1254 { 6185 /* i64.load8_s */, WebAssembly::LOAD8_S_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1255 { 6197 /* i64.load8_u */, WebAssembly::LOAD8_U_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1256 { 6197 /* i64.load8_u */, WebAssembly::LOAD8_U_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1257 { 6209 /* i64.lt_s */, WebAssembly::LT_S_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1258 { 6218 /* i64.lt_u */, WebAssembly::LT_U_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1259 { 6227 /* i64.mul */, WebAssembly::MUL_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1260 { 6235 /* i64.mul_wide_s */, WebAssembly::I64_MUL_WIDE_S_S, Convert_NoOperands, AMFBS_HasWideArithmetic, { }, },
1261 { 6250 /* i64.mul_wide_u */, WebAssembly::I64_MUL_WIDE_U_S, Convert_NoOperands, AMFBS_HasWideArithmetic, { }, },
1262 { 6265 /* i64.ne */, WebAssembly::NE_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1263 { 6272 /* i64.or */, WebAssembly::OR_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1264 { 6279 /* i64.popcnt */, WebAssembly::POPCNT_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1265 { 6290 /* i64.reinterpret_f64 */, WebAssembly::I64_REINTERPRET_F64_S, Convert_NoOperands, AMFBS_None, { }, },
1266 { 6310 /* i64.rem_s */, WebAssembly::REM_S_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1267 { 6320 /* i64.rem_u */, WebAssembly::REM_U_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1268 { 6330 /* i64.rotl */, WebAssembly::ROTL_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1269 { 6339 /* i64.rotr */, WebAssembly::ROTR_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1270 { 6348 /* i64.select */, WebAssembly::SELECT_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1271 { 6359 /* i64.shl */, WebAssembly::SHL_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1272 { 6367 /* i64.shr_s */, WebAssembly::SHR_S_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1273 { 6377 /* i64.shr_u */, WebAssembly::SHR_U_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1274 { 6387 /* i64.store */, WebAssembly::STORE_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1275 { 6387 /* i64.store */, WebAssembly::STORE_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1276 { 6397 /* i64.store16 */, WebAssembly::STORE16_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1277 { 6397 /* i64.store16 */, WebAssembly::STORE16_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1278 { 6409 /* i64.store32 */, WebAssembly::STORE32_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1279 { 6409 /* i64.store32 */, WebAssembly::STORE32_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1280 { 6421 /* i64.store8 */, WebAssembly::STORE8_I64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1281 { 6421 /* i64.store8 */, WebAssembly::STORE8_I64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1282 { 6432 /* i64.sub */, WebAssembly::SUB_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1283 { 6440 /* i64.sub128 */, WebAssembly::I64_SUB128_S, Convert_NoOperands, AMFBS_HasWideArithmetic, { }, },
1284 { 6451 /* i64.trunc_f32_s */, WebAssembly::I64_TRUNC_S_F32_S, Convert_NoOperands, AMFBS_None, { }, },
1285 { 6467 /* i64.trunc_f32_u */, WebAssembly::I64_TRUNC_U_F32_S, Convert_NoOperands, AMFBS_None, { }, },
1286 { 6483 /* i64.trunc_f64_s */, WebAssembly::I64_TRUNC_S_F64_S, Convert_NoOperands, AMFBS_None, { }, },
1287 { 6499 /* i64.trunc_f64_u */, WebAssembly::I64_TRUNC_U_F64_S, Convert_NoOperands, AMFBS_None, { }, },
1288 { 6515 /* i64.trunc_sat_f32_s */, WebAssembly::I64_TRUNC_S_SAT_F32_S, Convert_NoOperands, AMFBS_HasNontrappingFPToInt, { }, },
1289 { 6535 /* i64.trunc_sat_f32_u */, WebAssembly::I64_TRUNC_U_SAT_F32_S, Convert_NoOperands, AMFBS_HasNontrappingFPToInt, { }, },
1290 { 6555 /* i64.trunc_sat_f64_s */, WebAssembly::I64_TRUNC_S_SAT_F64_S, Convert_NoOperands, AMFBS_HasNontrappingFPToInt, { }, },
1291 { 6575 /* i64.trunc_sat_f64_u */, WebAssembly::I64_TRUNC_U_SAT_F64_S, Convert_NoOperands, AMFBS_HasNontrappingFPToInt, { }, },
1292 { 6595 /* i64.xor */, WebAssembly::XOR_I64_S, Convert_NoOperands, AMFBS_None, { }, },
1293 { 6603 /* i64x2.abs */, WebAssembly::ABS_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1294 { 6613 /* i64x2.add */, WebAssembly::ADD_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1295 { 6623 /* i64x2.all_true */, WebAssembly::ALLTRUE_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1296 { 6638 /* i64x2.bitmask */, WebAssembly::BITMASK_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1297 { 6652 /* i64x2.eq */, WebAssembly::EQ_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1298 { 6661 /* i64x2.extend_high_i32x4_s */, WebAssembly::extend_high_s_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1299 { 6687 /* i64x2.extend_high_i32x4_u */, WebAssembly::extend_high_u_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1300 { 6713 /* i64x2.extend_low_i32x4_s */, WebAssembly::extend_low_s_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1301 { 6738 /* i64x2.extend_low_i32x4_u */, WebAssembly::extend_low_u_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1302 { 6763 /* i64x2.extmul_high_i32x4_s */, WebAssembly::EXTMUL_HIGH_S_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1303 { 6789 /* i64x2.extmul_high_i32x4_u */, WebAssembly::EXTMUL_HIGH_U_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1304 { 6815 /* i64x2.extmul_low_i32x4_s */, WebAssembly::EXTMUL_LOW_S_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1305 { 6840 /* i64x2.extmul_low_i32x4_u */, WebAssembly::EXTMUL_LOW_U_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1306 { 6865 /* i64x2.extract_lane */, WebAssembly::EXTRACT_LANE_I64x2_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1307 { 6884 /* i64x2.ge_s */, WebAssembly::GE_S_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1308 { 6895 /* i64x2.gt_s */, WebAssembly::GT_S_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1309 { 6906 /* i64x2.le_s */, WebAssembly::LE_S_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1310 { 6917 /* i64x2.load32x2_s */, WebAssembly::LOAD_EXTEND_S_I64x2_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1311 { 6917 /* i64x2.load32x2_s */, WebAssembly::LOAD_EXTEND_S_I64x2_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1312 { 6934 /* i64x2.load32x2_u */, WebAssembly::LOAD_EXTEND_U_I64x2_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1313 { 6934 /* i64x2.load32x2_u */, WebAssembly::LOAD_EXTEND_U_I64x2_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1314 { 6951 /* i64x2.lt_s */, WebAssembly::LT_S_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1315 { 6962 /* i64x2.mul */, WebAssembly::MUL_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1316 { 6972 /* i64x2.ne */, WebAssembly::NE_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1317 { 6981 /* i64x2.neg */, WebAssembly::NEG_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1318 { 6991 /* i64x2.relaxed_laneselect */, WebAssembly::LANESELECT_I64x2_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
1319 { 7016 /* i64x2.replace_lane */, WebAssembly::REPLACE_LANE_I64x2_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1320 { 7035 /* i64x2.shl */, WebAssembly::SHL_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1321 { 7045 /* i64x2.shr_s */, WebAssembly::SHR_S_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1322 { 7057 /* i64x2.shr_u */, WebAssembly::SHR_U_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1323 { 7069 /* i64x2.splat */, WebAssembly::SPLAT_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1324 { 7081 /* i64x2.sub */, WebAssembly::SUB_I64x2_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1325 { 7091 /* i8x16.abs */, WebAssembly::ABS_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1326 { 7101 /* i8x16.add */, WebAssembly::ADD_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1327 { 7111 /* i8x16.add_sat_s */, WebAssembly::ADD_SAT_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1328 { 7127 /* i8x16.add_sat_u */, WebAssembly::ADD_SAT_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1329 { 7143 /* i8x16.all_true */, WebAssembly::ALLTRUE_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1330 { 7158 /* i8x16.avgr_u */, WebAssembly::AVGR_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1331 { 7171 /* i8x16.bitmask */, WebAssembly::BITMASK_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1332 { 7185 /* i8x16.eq */, WebAssembly::EQ_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1333 { 7194 /* i8x16.extract_lane_s */, WebAssembly::EXTRACT_LANE_I8x16_s_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1334 { 7215 /* i8x16.extract_lane_u */, WebAssembly::EXTRACT_LANE_I8x16_u_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1335 { 7236 /* i8x16.ge_s */, WebAssembly::GE_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1336 { 7247 /* i8x16.ge_u */, WebAssembly::GE_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1337 { 7258 /* i8x16.gt_s */, WebAssembly::GT_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1338 { 7269 /* i8x16.gt_u */, WebAssembly::GT_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1339 { 7280 /* i8x16.le_s */, WebAssembly::LE_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1340 { 7291 /* i8x16.le_u */, WebAssembly::LE_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1341 { 7302 /* i8x16.lt_s */, WebAssembly::LT_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1342 { 7313 /* i8x16.lt_u */, WebAssembly::LT_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1343 { 7324 /* i8x16.max_s */, WebAssembly::MAX_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1344 { 7336 /* i8x16.max_u */, WebAssembly::MAX_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1345 { 7348 /* i8x16.min_s */, WebAssembly::MIN_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1346 { 7360 /* i8x16.min_u */, WebAssembly::MIN_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1347 { 7372 /* i8x16.narrow_i16x8_s */, WebAssembly::NARROW_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1348 { 7393 /* i8x16.narrow_i16x8_u */, WebAssembly::NARROW_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1349 { 7414 /* i8x16.ne */, WebAssembly::NE_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1350 { 7423 /* i8x16.neg */, WebAssembly::NEG_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1351 { 7433 /* i8x16.popcnt */, WebAssembly::POPCNT_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1352 { 7446 /* i8x16.relaxed_laneselect */, WebAssembly::LANESELECT_I8x16_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
1353 { 7471 /* i8x16.relaxed_swizzle */, WebAssembly::RELAXED_SWIZZLE_S, Convert_NoOperands, AMFBS_HasRelaxedSIMD, { }, },
1354 { 7493 /* i8x16.replace_lane */, WebAssembly::REPLACE_LANE_I8x16_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1355 { 7512 /* i8x16.shl */, WebAssembly::SHL_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1356 { 7522 /* i8x16.shr_s */, WebAssembly::SHR_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1357 { 7534 /* i8x16.shr_u */, WebAssembly::SHR_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1358 { 7546 /* i8x16.shuffle */, WebAssembly::SHUFFLE_S, Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3__Imm1_4__Imm1_5__Imm1_6__Imm1_7__Imm1_8__Imm1_9__Imm1_10__Imm1_11__Imm1_12__Imm1_13__Imm1_14__Imm1_15, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm }, },
1359 { 7560 /* i8x16.splat */, WebAssembly::SPLAT_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1360 { 7572 /* i8x16.sub */, WebAssembly::SUB_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1361 { 7582 /* i8x16.sub_sat_s */, WebAssembly::SUB_SAT_S_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1362 { 7598 /* i8x16.sub_sat_u */, WebAssembly::SUB_SAT_U_I8x16_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1363 { 7614 /* i8x16.swizzle */, WebAssembly::SWIZZLE_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1364 { 7628 /* if */, WebAssembly::IF_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1365 { 7631 /* local.get */, WebAssembly::LOCAL_GET_EXNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes_HasExceptionHandling, { MCK_Imm }, },
1366 { 7631 /* local.get */, WebAssembly::LOCAL_GET_EXTERNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1367 { 7631 /* local.get */, WebAssembly::LOCAL_GET_FUNCREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1368 { 7631 /* local.get */, WebAssembly::LOCAL_GET_V128_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1369 { 7631 /* local.get */, WebAssembly::LOCAL_GET_F32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1370 { 7631 /* local.get */, WebAssembly::LOCAL_GET_F64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1371 { 7631 /* local.get */, WebAssembly::LOCAL_GET_I32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1372 { 7631 /* local.get */, WebAssembly::LOCAL_GET_I64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1373 { 7641 /* local.set */, WebAssembly::LOCAL_SET_EXNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes_HasExceptionHandling, { MCK_Imm }, },
1374 { 7641 /* local.set */, WebAssembly::LOCAL_SET_EXTERNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1375 { 7641 /* local.set */, WebAssembly::LOCAL_SET_FUNCREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1376 { 7641 /* local.set */, WebAssembly::LOCAL_SET_V128_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1377 { 7641 /* local.set */, WebAssembly::LOCAL_SET_F32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1378 { 7641 /* local.set */, WebAssembly::LOCAL_SET_F64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1379 { 7641 /* local.set */, WebAssembly::LOCAL_SET_I32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1380 { 7641 /* local.set */, WebAssembly::LOCAL_SET_I64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1381 { 7651 /* local.tee */, WebAssembly::LOCAL_TEE_EXNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes_HasExceptionHandling, { MCK_Imm }, },
1382 { 7651 /* local.tee */, WebAssembly::LOCAL_TEE_EXTERNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1383 { 7651 /* local.tee */, WebAssembly::LOCAL_TEE_FUNCREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1384 { 7651 /* local.tee */, WebAssembly::LOCAL_TEE_V128_S, Convert__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm }, },
1385 { 7651 /* local.tee */, WebAssembly::LOCAL_TEE_F32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1386 { 7651 /* local.tee */, WebAssembly::LOCAL_TEE_F64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1387 { 7651 /* local.tee */, WebAssembly::LOCAL_TEE_I32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1388 { 7651 /* local.tee */, WebAssembly::LOCAL_TEE_I64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1389 { 7661 /* loop */, WebAssembly::LOOP_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1390 { 7666 /* memory.atomic.notify */, WebAssembly::MEMORY_ATOMIC_NOTIFY_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1391 { 7666 /* memory.atomic.notify */, WebAssembly::MEMORY_ATOMIC_NOTIFY_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1392 { 7687 /* memory.atomic.wait32 */, WebAssembly::MEMORY_ATOMIC_WAIT32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1393 { 7687 /* memory.atomic.wait32 */, WebAssembly::MEMORY_ATOMIC_WAIT32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1394 { 7708 /* memory.atomic.wait64 */, WebAssembly::MEMORY_ATOMIC_WAIT64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1395 { 7708 /* memory.atomic.wait64 */, WebAssembly::MEMORY_ATOMIC_WAIT64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasAtomics, { MCK_Imm, MCK_Imm }, },
1396 { 7729 /* memory.copy */, WebAssembly::MEMORY_COPY_A32_S, Convert__Imm1_0__Imm1_1, AMFBS_HasBulkMemoryOpt, { MCK_Imm, MCK_Imm }, },
1397 { 7729 /* memory.copy */, WebAssembly::MEMORY_COPY_A64_S, Convert__Imm1_0__Imm1_1, AMFBS_HasBulkMemoryOpt, { MCK_Imm, MCK_Imm }, },
1398 { 7741 /* memory.fill */, WebAssembly::MEMORY_FILL_A32_S, Convert__Imm1_0, AMFBS_HasBulkMemoryOpt, { MCK_Imm }, },
1399 { 7741 /* memory.fill */, WebAssembly::MEMORY_FILL_A64_S, Convert__Imm1_0, AMFBS_HasBulkMemoryOpt, { MCK_Imm }, },
1400 { 7753 /* memory.grow */, WebAssembly::anonymous_8818MEMORY_GROW_A32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1401 { 7753 /* memory.grow */, WebAssembly::anonymous_8819MEMORY_GROW_A64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1402 { 7765 /* memory.init */, WebAssembly::MEMORY_INIT_A32_S, Convert__Imm1_0__Imm1_1, AMFBS_HasBulkMemoryOpt, { MCK_Imm, MCK_Imm }, },
1403 { 7765 /* memory.init */, WebAssembly::MEMORY_INIT_A64_S, Convert__Imm1_0__Imm1_1, AMFBS_HasBulkMemoryOpt, { MCK_Imm, MCK_Imm }, },
1404 { 7777 /* memory.size */, WebAssembly::anonymous_8818MEMORY_SIZE_A32_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1405 { 7777 /* memory.size */, WebAssembly::anonymous_8819MEMORY_SIZE_A64_S, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1406 { 7789 /* nop */, WebAssembly::NOP_S, Convert_NoOperands, AMFBS_None, { }, },
1407 { 7793 /* ref.is_null */, WebAssembly::REF_IS_NULL_EXNREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
1408 { 7793 /* ref.is_null */, WebAssembly::REF_IS_NULL_EXTERNREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
1409 { 7793 /* ref.is_null */, WebAssembly::REF_IS_NULL_FUNCREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
1410 { 7805 /* ref.null_exn */, WebAssembly::REF_NULL_EXNREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
1411 { 7818 /* ref.null_extern */, WebAssembly::REF_NULL_EXTERNREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
1412 { 7834 /* ref.null_func */, WebAssembly::REF_NULL_FUNCREF_S, Convert_NoOperands, AMFBS_HasReferenceTypes, { }, },
1413 { 7848 /* rethrow */, WebAssembly::RETHROW_S, Convert__Imm1_0, AMFBS_HasExceptionHandling, { MCK_Imm }, },
1414 { 7856 /* return */, WebAssembly::RETURN_S, Convert_NoOperands, AMFBS_None, { }, },
1415 { 7863 /* return_call */, WebAssembly::RET_CALL_S, Convert__Imm1_0, AMFBS_HasTailCall, { MCK_Imm }, },
1416 { 7875 /* return_call_indirect */, WebAssembly::RET_CALL_INDIRECT_S, Convert__Imm1_0__Imm1_1, AMFBS_HasTailCall, { MCK_Imm, MCK_Imm }, },
1417 { 7896 /* return_call_results */, WebAssembly::RET_CALL_RESULTS_S, Convert_NoOperands, AMFBS_None, { }, },
1418 { 7916 /* table.copy */, WebAssembly::TABLE_COPY_S, Convert__Imm1_0__Imm1_1, AMFBS_HasReferenceTypes, { MCK_Imm, MCK_Imm }, },
1419 { 7927 /* table.fill */, WebAssembly::TABLE_FILL_EXNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes_HasExceptionHandling, { MCK_Imm }, },
1420 { 7927 /* table.fill */, WebAssembly::TABLE_FILL_EXTERNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1421 { 7927 /* table.fill */, WebAssembly::TABLE_FILL_FUNCREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1422 { 7938 /* table.get */, WebAssembly::TABLE_GET_EXNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes_HasExceptionHandling, { MCK_Imm }, },
1423 { 7938 /* table.get */, WebAssembly::TABLE_GET_EXTERNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1424 { 7938 /* table.get */, WebAssembly::TABLE_GET_FUNCREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1425 { 7948 /* table.grow */, WebAssembly::TABLE_GROW_EXNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes_HasExceptionHandling, { MCK_Imm }, },
1426 { 7948 /* table.grow */, WebAssembly::TABLE_GROW_EXTERNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1427 { 7948 /* table.grow */, WebAssembly::TABLE_GROW_FUNCREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1428 { 7959 /* table.set */, WebAssembly::TABLE_SET_EXNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes_HasExceptionHandling, { MCK_Imm }, },
1429 { 7959 /* table.set */, WebAssembly::TABLE_SET_EXTERNREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1430 { 7959 /* table.set */, WebAssembly::TABLE_SET_FUNCREF_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1431 { 7969 /* table.size */, WebAssembly::TABLE_SIZE_S, Convert__Imm1_0, AMFBS_HasReferenceTypes, { MCK_Imm }, },
1432 { 7980 /* throw */, WebAssembly::THROW_S, Convert__Imm1_0, AMFBS_HasExceptionHandling, { MCK_Imm }, },
1433 { 7986 /* throw_ref */, WebAssembly::THROW_REF_S, Convert_NoOperands, AMFBS_HasExceptionHandling, { }, },
1434 { 7996 /* try */, WebAssembly::TRY_S, Convert__Imm1_0, AMFBS_HasExceptionHandling, { MCK_Imm }, },
1435 { 8000 /* try_table */, WebAssembly::TRY_TABLE_S, Convert__Imm1_0__CatchList1_1, AMFBS_HasExceptionHandling, { MCK_Imm, MCK_CatchList }, },
1436 { 8010 /* unreachable */, WebAssembly::DEBUG_UNREACHABLE_S, Convert_NoOperands, AMFBS_None, { }, },
1437 { 8010 /* unreachable */, WebAssembly::UNREACHABLE_S, Convert_NoOperands, AMFBS_None, { }, },
1438 { 8022 /* v128.and */, WebAssembly::AND_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1439 { 8031 /* v128.andnot */, WebAssembly::ANDNOT_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1440 { 8043 /* v128.any_true */, WebAssembly::ANYTRUE_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1441 { 8057 /* v128.bitselect */, WebAssembly::BITSELECT_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1442 { 8072 /* v128.const */, WebAssembly::CONST_V128_I64x2_S, Convert__Imm1_0__Imm1_1, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1443 { 8072 /* v128.const */, WebAssembly::CONST_V128_F64x2_S, Convert__FPImmf641_0__FPImmf641_1, AMFBS_HasSIMD128, { MCK_FPImmf64, MCK_FPImmf64 }, },
1444 { 8072 /* v128.const */, WebAssembly::CONST_V128_I32x4_S, Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm }, },
1445 { 8072 /* v128.const */, WebAssembly::CONST_V128_F32x4_S, Convert__FPImmf321_0__FPImmf321_1__FPImmf321_2__FPImmf321_3, AMFBS_HasSIMD128, { MCK_FPImmf32, MCK_FPImmf32, MCK_FPImmf32, MCK_FPImmf32 }, },
1446 { 8072 /* v128.const */, WebAssembly::CONST_V128_I16x8_S, Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3__Imm1_4__Imm1_5__Imm1_6__Imm1_7, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm }, },
1447 { 8072 /* v128.const */, WebAssembly::CONST_V128_I8x16_S, Convert__Imm1_0__Imm1_1__Imm1_2__Imm1_3__Imm1_4__Imm1_5__Imm1_6__Imm1_7__Imm1_8__Imm1_9__Imm1_10__Imm1_11__Imm1_12__Imm1_13__Imm1_14__Imm1_15, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm, MCK_Imm }, },
1448 { 8083 /* v128.load */, WebAssembly::LOAD_V128_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1449 { 8083 /* v128.load */, WebAssembly::LOAD_V128_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1450 { 8093 /* v128.load16_lane */, WebAssembly::LOAD_LANE_16_A32_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1451 { 8093 /* v128.load16_lane */, WebAssembly::LOAD_LANE_16_A64_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1452 { 8110 /* v128.load16_splat */, WebAssembly::LOAD16_SPLAT_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1453 { 8110 /* v128.load16_splat */, WebAssembly::LOAD16_SPLAT_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1454 { 8128 /* v128.load32_lane */, WebAssembly::LOAD_LANE_32_A32_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1455 { 8128 /* v128.load32_lane */, WebAssembly::LOAD_LANE_32_A64_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1456 { 8145 /* v128.load32_splat */, WebAssembly::LOAD32_SPLAT_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1457 { 8145 /* v128.load32_splat */, WebAssembly::LOAD32_SPLAT_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1458 { 8163 /* v128.load32_zero */, WebAssembly::LOAD_ZERO_32_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1459 { 8163 /* v128.load32_zero */, WebAssembly::LOAD_ZERO_32_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1460 { 8180 /* v128.load64_lane */, WebAssembly::LOAD_LANE_64_A32_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1461 { 8180 /* v128.load64_lane */, WebAssembly::LOAD_LANE_64_A64_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1462 { 8197 /* v128.load64_splat */, WebAssembly::LOAD64_SPLAT_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1463 { 8197 /* v128.load64_splat */, WebAssembly::LOAD64_SPLAT_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1464 { 8215 /* v128.load64_zero */, WebAssembly::LOAD_ZERO_64_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1465 { 8215 /* v128.load64_zero */, WebAssembly::LOAD_ZERO_64_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1466 { 8232 /* v128.load8_lane */, WebAssembly::LOAD_LANE_8_A32_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1467 { 8232 /* v128.load8_lane */, WebAssembly::LOAD_LANE_8_A64_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1468 { 8248 /* v128.load8_splat */, WebAssembly::LOAD8_SPLAT_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1469 { 8248 /* v128.load8_splat */, WebAssembly::LOAD8_SPLAT_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1470 { 8265 /* v128.not */, WebAssembly::NOT_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1471 { 8274 /* v128.or */, WebAssembly::OR_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1472 { 8282 /* v128.select */, WebAssembly::SELECT_V128_S, Convert_NoOperands, AMFBS_None, { }, },
1473 { 8294 /* v128.store */, WebAssembly::STORE_V128_A32_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1474 { 8294 /* v128.store */, WebAssembly::STORE_V128_A64_S, Convert__Imm1_1__Imm1_0, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm }, },
1475 { 8305 /* v128.store16_lane */, WebAssembly::STORE_LANE_I16x8_A32_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1476 { 8305 /* v128.store16_lane */, WebAssembly::STORE_LANE_I16x8_A64_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1477 { 8323 /* v128.store32_lane */, WebAssembly::STORE_LANE_I32x4_A32_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1478 { 8323 /* v128.store32_lane */, WebAssembly::STORE_LANE_I32x4_A64_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1479 { 8341 /* v128.store64_lane */, WebAssembly::STORE_LANE_I64x2_A32_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1480 { 8341 /* v128.store64_lane */, WebAssembly::STORE_LANE_I64x2_A64_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1481 { 8359 /* v128.store8_lane */, WebAssembly::STORE_LANE_I8x16_A32_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1482 { 8359 /* v128.store8_lane */, WebAssembly::STORE_LANE_I8x16_A64_S, Convert__Imm1_1__Imm1_0__Imm1_2, AMFBS_HasSIMD128, { MCK_Imm, MCK_Imm, MCK_Imm }, },
1483 { 8376 /* v128.xor */, WebAssembly::XOR_S, Convert_NoOperands, AMFBS_HasSIMD128, { }, },
1484};
1485
1486#include "llvm/Support/Debug.h"
1487#include "llvm/Support/Format.h"
1488
1489unsigned WebAssemblyAsmParser::
1490MatchInstructionImpl(const OperandVector &Operands,
1491 MCInst &Inst,
1492 uint64_t &ErrorInfo,
1493 FeatureBitset &MissingFeatures,
1494 bool matchingInlineAsm, unsigned VariantID) {
1495 // Eliminate obvious mismatches.
1496 if (Operands.size() > 17) {
1497 ErrorInfo = 17;
1498 return Match_InvalidOperand;
1499 }
1500
1501 // Get the current feature set.
1502 const FeatureBitset &AvailableFeatures = getAvailableFeatures();
1503
1504 // Get the instruction mnemonic, which is the first token.
1505 StringRef Mnemonic = ((WebAssemblyOperand &)*Operands[0]).getToken();
1506
1507 // Some state to try to produce better error messages.
1508 bool HadMatchOtherThanFeatures = false;
1509 bool HadMatchOtherThanPredicate = false;
1510 unsigned RetCode = Match_InvalidOperand;
1511 MissingFeatures.set();
1512 // Set ErrorInfo to the operand that mismatches if it is
1513 // wrong for all instances of the instruction.
1514 ErrorInfo = ~0ULL;
1515 // Find the appropriate table for this asm variant.
1516 const MatchEntry *Start, *End;
1517 switch (VariantID) {
1518 default: llvm_unreachable("invalid variant!");
1519 case 0: Start = std::begin(MatchTable0); End = std::end(MatchTable0); break;
1520 }
1521 // Search the table.
1522 auto MnemonicRange = std::equal_range(Start, End, Mnemonic, LessOpcode());
1523
1524 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "AsmMatcher: found " <<
1525 std::distance(MnemonicRange.first, MnemonicRange.second) <<
1526 " encodings with mnemonic '" << Mnemonic << "'\n");
1527
1528 // Return a more specific error code if no mnemonics match.
1529 if (MnemonicRange.first == MnemonicRange.second)
1530 return Match_MnemonicFail;
1531
1532 for (const MatchEntry *it = MnemonicRange.first, *ie = MnemonicRange.second;
1533 it != ie; ++it) {
1534 const FeatureBitset &RequiredFeatures = FeatureBitsets[it->RequiredFeaturesIdx];
1535 bool HasRequiredFeatures =
1536 (AvailableFeatures & RequiredFeatures) == RequiredFeatures;
1537 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "Trying to match opcode "
1538 << MII.getName(it->Opcode) << "\n");
1539 // equal_range guarantees that instruction mnemonic matches.
1540 assert(Mnemonic == it->getMnemonic());
1541 bool OperandsValid = true;
1542 for (unsigned FormalIdx = 0, ActualIdx = 1; FormalIdx != 16; ++FormalIdx) {
1543 auto Formal = static_cast<MatchClassKind>(it->Classes[FormalIdx]);
1544 DEBUG_WITH_TYPE("asm-matcher",
1545 dbgs() << " Matching formal operand class " << getMatchClassName(Formal)
1546 << " against actual operand at index " << ActualIdx);
1547 if (ActualIdx < Operands.size())
1548 DEBUG_WITH_TYPE("asm-matcher", dbgs() << " (";
1549 Operands[ActualIdx]->print(dbgs(), *getContext().getAsmInfo()); dbgs() << "): ");
1550 else
1551 DEBUG_WITH_TYPE("asm-matcher", dbgs() << ": ");
1552 if (ActualIdx >= Operands.size()) {
1553 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "actual operand index out of range\n");
1554 if (Formal == InvalidMatchClass) {
1555 break;
1556 }
1557 if (isSubclass(Formal, OptionalMatchClass)) {
1558 continue;
1559 }
1560 OperandsValid = false;
1561 ErrorInfo = ActualIdx;
1562 break;
1563 }
1564 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
1565 unsigned Diag = validateOperandClass(Actual, Formal);
1566 if (Diag == Match_Success) {
1567 DEBUG_WITH_TYPE("asm-matcher",
1568 dbgs() << "match success using generic matcher\n");
1569 ++ActualIdx;
1570 continue;
1571 }
1572 // If the generic handler indicates an invalid operand
1573 // failure, check for a special case.
1574 if (Diag != Match_Success) {
1575 unsigned TargetDiag = validateTargetOperandClass(Actual, Formal);
1576 if (TargetDiag == Match_Success) {
1577 DEBUG_WITH_TYPE("asm-matcher",
1578 dbgs() << "match success using target matcher\n");
1579 ++ActualIdx;
1580 continue;
1581 }
1582 // If the target matcher returned a specific error code use
1583 // that, else use the one from the generic matcher.
1584 if (TargetDiag != Match_InvalidOperand && HasRequiredFeatures)
1585 Diag = TargetDiag;
1586 }
1587 // If current formal operand wasn't matched and it is optional
1588 // then try to match next formal operand
1589 if (Diag == Match_InvalidOperand && isSubclass(Formal, OptionalMatchClass)) {
1590 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "ignoring optional operand\n");
1591 continue;
1592 }
1593 // If this operand is broken for all of the instances of this
1594 // mnemonic, keep track of it so we can report loc info.
1595 // If we already had a match that only failed due to a
1596 // target predicate, that diagnostic is preferred.
1597 if (!HadMatchOtherThanPredicate &&
1598 (it == MnemonicRange.first || ErrorInfo <= ActualIdx)) {
1599 if (HasRequiredFeatures && (ErrorInfo != ActualIdx || Diag != Match_InvalidOperand))
1600 RetCode = Diag;
1601 ErrorInfo = ActualIdx;
1602 }
1603 // Otherwise, just reject this instance of the mnemonic.
1604 OperandsValid = false;
1605 break;
1606 }
1607
1608 if (!OperandsValid) {
1609 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "Opcode result: multiple "
1610 "operand mismatches, ignoring "
1611 "this opcode\n");
1612 continue;
1613 }
1614 if (!HasRequiredFeatures) {
1615 HadMatchOtherThanFeatures = true;
1616 FeatureBitset NewMissingFeatures = RequiredFeatures & ~AvailableFeatures;
1617 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "Missing target features:";
1618 for (unsigned I = 0, E = NewMissingFeatures.size(); I != E; ++I)
1619 if (NewMissingFeatures[I])
1620 dbgs() << ' ' << I;
1621 dbgs() << "\n");
1622 if (NewMissingFeatures.count() <=
1623 MissingFeatures.count())
1624 MissingFeatures = NewMissingFeatures;
1625 continue;
1626 }
1627
1628 Inst.clear();
1629
1630 Inst.setOpcode(it->Opcode);
1631 // We have a potential match but have not rendered the operands.
1632 // Check the target predicate to handle any context sensitive
1633 // constraints.
1634 // For example, Ties that are referenced multiple times must be
1635 // checked here to ensure the input is the same for each match
1636 // constraints. If we leave it any later the ties will have been
1637 // canonicalized
1638 unsigned MatchResult;
1639 if ((MatchResult = checkEarlyTargetMatchPredicate(Inst, Operands)) != Match_Success) {
1640 Inst.clear();
1641 DEBUG_WITH_TYPE(
1642 "asm-matcher",
1643 dbgs() << "Early target match predicate failed with diag code "
1644 << MatchResult << "\n");
1645 RetCode = MatchResult;
1646 HadMatchOtherThanPredicate = true;
1647 continue;
1648 }
1649
1650 if (matchingInlineAsm) {
1651 convertToMapAndConstraints(it->ConvertFn, Operands);
1652 if (!checkAsmTiedOperandConstraints(*this, it->ConvertFn, Operands,
1653 ErrorInfo))
1654 return Match_InvalidTiedOperand;
1655
1656 return Match_Success;
1657 }
1658
1659 // We have selected a definite instruction, convert the parsed
1660 // operands into the appropriate MCInst.
1661 convertToMCInst(it->ConvertFn, Inst, it->Opcode, Operands);
1662
1663 // We have a potential match. Check the target predicate to
1664 // handle any context sensitive constraints.
1665 if ((MatchResult = checkTargetMatchPredicate(Inst)) != Match_Success) {
1666 DEBUG_WITH_TYPE("asm-matcher",
1667 dbgs() << "Target match predicate failed with diag code "
1668 << MatchResult << "\n");
1669 Inst.clear();
1670 RetCode = MatchResult;
1671 HadMatchOtherThanPredicate = true;
1672 continue;
1673 }
1674
1675 if (!checkAsmTiedOperandConstraints(*this, it->ConvertFn, Operands,
1676 ErrorInfo))
1677 return Match_InvalidTiedOperand;
1678
1679 DEBUG_WITH_TYPE(
1680 "asm-matcher",
1681 dbgs() << "Opcode result: complete match, selecting this opcode\n");
1682 return Match_Success;
1683 }
1684
1685 // Okay, we had no match. Try to return a useful error code.
1686 if (HadMatchOtherThanPredicate || !HadMatchOtherThanFeatures)
1687 return RetCode;
1688
1689 ErrorInfo = 0;
1690 return Match_MissingFeature;
1691}
1692
1693#endif // GET_MATCHER_IMPLEMENTATION
1694
1695
1696#ifdef GET_MNEMONIC_SPELL_CHECKER
1697#undef GET_MNEMONIC_SPELL_CHECKER
1698
1699static std::string WebAssemblyMnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, unsigned VariantID) {
1700 const unsigned MaxEditDist = 2;
1701 std::vector<StringRef> Candidates;
1702 StringRef Prev = "";
1703
1704 // Find the appropriate table for this asm variant.
1705 const MatchEntry *Start, *End;
1706 switch (VariantID) {
1707 default: llvm_unreachable("invalid variant!");
1708 case 0: Start = std::begin(MatchTable0); End = std::end(MatchTable0); break;
1709 }
1710
1711 for (auto I = Start; I < End; I++) {
1712 // Ignore unsupported instructions.
1713 const FeatureBitset &RequiredFeatures = FeatureBitsets[I->RequiredFeaturesIdx];
1714 if ((FBS & RequiredFeatures) != RequiredFeatures)
1715 continue;
1716
1717 StringRef T = I->getMnemonic();
1718 // Avoid recomputing the edit distance for the same string.
1719 if (T == Prev)
1720 continue;
1721
1722 Prev = T;
1723 unsigned Dist = S.edit_distance(T, false, MaxEditDist);
1724 if (Dist <= MaxEditDist)
1725 Candidates.push_back(T);
1726 }
1727
1728 if (Candidates.empty())
1729 return "";
1730
1731 std::string Res = ", did you mean: ";
1732 unsigned i = 0;
1733 for (; i < Candidates.size() - 1; i++)
1734 Res += Candidates[i].str() + ", ";
1735 return Res + Candidates[i].str() + "?";
1736}
1737
1738#endif // GET_MNEMONIC_SPELL_CHECKER
1739
1740
1741#ifdef GET_MNEMONIC_CHECKER
1742#undef GET_MNEMONIC_CHECKER
1743
1744static bool WebAssemblyCheckMnemonic(StringRef Mnemonic,
1745 const FeatureBitset &AvailableFeatures,
1746 unsigned VariantID) {
1747 // Find the appropriate table for this asm variant.
1748 const MatchEntry *Start, *End;
1749 switch (VariantID) {
1750 default: llvm_unreachable("invalid variant!");
1751 case 0: Start = std::begin(MatchTable0); End = std::end(MatchTable0); break;
1752 }
1753
1754 // Search the table.
1755 auto MnemonicRange = std::equal_range(Start, End, Mnemonic, LessOpcode());
1756
1757 if (MnemonicRange.first == MnemonicRange.second)
1758 return false;
1759
1760 for (const MatchEntry *it = MnemonicRange.first, *ie = MnemonicRange.second;
1761 it != ie; ++it) {
1762 const FeatureBitset &RequiredFeatures =
1763 FeatureBitsets[it->RequiredFeaturesIdx];
1764 if ((AvailableFeatures & RequiredFeatures) == RequiredFeatures)
1765 return true;
1766 }
1767 return false;
1768}
1769
1770#endif // GET_MNEMONIC_CHECKER
1771
1772