1 // GENERATED BY ISLE. DO NOT EDIT!
2 //
3 // Generated automatically from the instruction-selection DSL code in:
4 // - src/clif.isle
5 // - src/prelude.isle
6 // - src/isa/x64/inst.isle
7 // - src/isa/x64/lower.isle
8 
9 #![allow(dead_code, unreachable_code, unreachable_patterns)]
10 #![allow(unused_imports, unused_variables, non_snake_case)]
11 #![allow(irrefutable_let_patterns)]
12 
13 use super::*; // Pulls in all external types.
14 
15 /// Context during lowering: an implementation of this trait
16 /// must be provided with all external constructors and extractors.
17 /// A mutable borrow is passed along through all lowering logic.
18 pub trait Context {
19     fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);
20     fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
21     fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);
22     fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
23     fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;
24     fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
25     fn value_reg(&mut self, arg0: Reg) -> ValueRegs;
26     fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs;
27     fn value_regs_invalid(&mut self) -> ValueRegs;
28     fn output_none(&mut self) -> InstOutput;
29     fn output(&mut self, arg0: ValueRegs) -> InstOutput;
30     fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput;
31     fn output_builder_new(&mut self) -> InstOutputBuilder;
32     fn output_builder_push(&mut self, arg0: &InstOutputBuilder, arg1: ValueRegs) -> Unit;
33     fn output_builder_finish(&mut self, arg0: &InstOutputBuilder) -> InstOutput;
34     fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg;
35     fn invalid_reg(&mut self) -> Reg;
36     fn put_in_reg(&mut self, arg0: Value) -> Reg;
37     fn put_in_regs(&mut self, arg0: Value) -> ValueRegs;
38     fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg;
39     fn u8_as_u64(&mut self, arg0: u8) -> u64;
40     fn u16_as_u64(&mut self, arg0: u16) -> u64;
41     fn u32_as_u64(&mut self, arg0: u32) -> u64;
42     fn i64_as_u64(&mut self, arg0: i64) -> u64;
43     fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;
44     fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;
45     fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;
46     fn ty_bits(&mut self, arg0: Type) -> u8;
47     fn ty_bits_u16(&mut self, arg0: Type) -> u16;
48     fn ty_bits_u64(&mut self, arg0: Type) -> u64;
49     fn ty_mask(&mut self, arg0: Type) -> u64;
50     fn ty_bytes(&mut self, arg0: Type) -> u16;
51     fn lane_type(&mut self, arg0: Type) -> Type;
52     fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
53     fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
54     fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
55     fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
56     fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
57     fn ty_int_bool_64(&mut self, arg0: Type) -> Option<Type>;
58     fn ty_int_bool_ref_64(&mut self, arg0: Type) -> Option<Type>;
59     fn ty_int_bool_128(&mut self, arg0: Type) -> Option<Type>;
60     fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
61     fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
62     fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
63     fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice;
64     fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>;
65     fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>;
66     fn value_slice_len(&mut self, arg0: ValueSlice) -> usize;
67     fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value;
68     fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg;
69     fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
70     fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
71     fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
72     fn u64_from_ieee32(&mut self, arg0: Ieee32) -> u64;
73     fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
74     fn inst_results(&mut self, arg0: Inst) -> ValueSlice;
75     fn first_result(&mut self, arg0: Inst) -> Option<Value>;
76     fn inst_data(&mut self, arg0: Inst) -> InstructionData;
77     fn value_type(&mut self, arg0: Value) -> Type;
78     fn multi_lane(&mut self, arg0: Type) -> Option<(u8, u16)>;
79     fn def_inst(&mut self, arg0: Value) -> Option<Inst>;
80     fn offset32_to_u32(&mut self, arg0: Offset32) -> u32;
81     fn emit(&mut self, arg0: &MInst) -> Unit;
82     fn trap_code_division_by_zero(&mut self) -> TrapCode;
83     fn trap_code_integer_overflow(&mut self) -> TrapCode;
84     fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;
85     fn avoid_div_traps(&mut self, arg0: Type) -> Option<()>;
86     fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance);
87     fn symbol_value_data(
88         &mut self,
89         arg0: GlobalValue,
90     ) -> Option<(ExternalName, RelocDistance, i64)>;
91     fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>;
92     fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;
93     fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;
94     fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm;
95     fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem;
96     fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem;
97     fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode;
98     fn amode_with_flags(&mut self, arg0: &Amode, arg1: MemFlags) -> Amode;
99     fn amode_imm_reg(&mut self, arg0: u32, arg1: Gpr) -> Amode;
100     fn amode_imm_reg_reg_shift(&mut self, arg0: u32, arg1: Gpr, arg2: Gpr, arg3: u8) -> Amode;
101     fn const_shift_lt_eq_3(&mut self, arg0: Value) -> Option<u8>;
102     fn sum_extend_fits_in_32_bits(
103         &mut self,
104         arg0: Offset32,
105         arg1: Type,
106         arg2: Imm64,
107     ) -> Option<u32>;
108     fn put_masked_in_imm8_gpr(&mut self, arg0: Value, arg1: Type) -> Imm8Gpr;
109     fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC;
110     fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8;
111     fn imm8_reg_to_imm8_gpr(&mut self, arg0: &Imm8Reg) -> Imm8Gpr;
112     fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg;
113     fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg;
114     fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm;
115     fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm;
116     fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr;
117     fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg;
118     fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem;
119     fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm;
120     fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg;
121     fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm;
122     fn temp_writable_gpr(&mut self) -> WritableGpr;
123     fn temp_writable_xmm(&mut self) -> WritableXmm;
124     fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem;
125     fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm;
126     fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm;
127     fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem;
128     fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem;
129     fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem;
130     fn xmm_new(&mut self, arg0: Reg) -> Xmm;
131     fn gpr_new(&mut self, arg0: Reg) -> Gpr;
132     fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem;
133     fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem;
134     fn gpr_to_imm8_gpr(&mut self, arg0: Gpr) -> Imm8Gpr;
135     fn imm8_to_imm8_gpr(&mut self, arg0: u8) -> Imm8Gpr;
136     fn xmm0(&mut self) -> WritableXmm;
137     fn is_xmm_type(&mut self, arg0: Type) -> Option<Type>;
138     fn is_gpr_type(&mut self, arg0: Type) -> Option<Type>;
139     fn is_single_register_type(&mut self, arg0: Type) -> Option<Type>;
140     fn avx512vl_enabled(&mut self, arg0: Type) -> Option<()>;
141     fn avx512dq_enabled(&mut self, arg0: Type) -> Option<()>;
142     fn avx512f_enabled(&mut self, arg0: Type) -> Option<()>;
143     fn avx512bitalg_enabled(&mut self, arg0: Type) -> Option<()>;
144     fn use_lzcnt(&mut self, arg0: Type) -> Option<()>;
145     fn use_bmi1(&mut self, arg0: Type) -> Option<()>;
146     fn use_popcnt(&mut self, arg0: Type) -> Option<()>;
147     fn imm8_from_value(&mut self, arg0: Value) -> Option<Imm8Reg>;
148     fn const_to_type_masked_imm8(&mut self, arg0: u64, arg1: Type) -> Imm8Gpr;
149     fn simm32_from_value(&mut self, arg0: Value) -> Option<GprMemImm>;
150     fn simm32_from_imm64(&mut self, arg0: Imm64) -> Option<GprMemImm>;
151     fn sinkable_load(&mut self, arg0: Value) -> Option<SinkableLoad>;
152     fn sink_load(&mut self, arg0: &SinkableLoad) -> RegMemImm;
153     fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode;
154     fn nonzero_u64_fits_in_u32(&mut self, arg0: u64) -> Option<u64>;
155     fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
156     fn ishl_i8x16_mask_table(&mut self) -> SyntheticAmode;
157     fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
158     fn ushr_i8x16_mask_table(&mut self) -> SyntheticAmode;
159     fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8;
160     fn popcount_4bit_table(&mut self) -> VCodeConstant;
161     fn popcount_low_mask(&mut self) -> VCodeConstant;
162 }
163 
164 /// Internal type SideEffectNoResult: defined at src/prelude.isle line 402.
165 #[derive(Clone, Debug)]
166 pub enum SideEffectNoResult {
167     Inst { inst: MInst },
168 }
169 
170 /// Internal type ProducesFlags: defined at src/prelude.isle line 418.
171 #[derive(Clone, Debug)]
172 pub enum ProducesFlags {
173     ProducesFlagsSideEffect { inst: MInst },
174     ProducesFlagsReturnsReg { inst: MInst, result: Reg },
175     ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg },
176 }
177 
178 /// Internal type ConsumesFlags: defined at src/prelude.isle line 429.
179 #[derive(Clone, Debug)]
180 pub enum ConsumesFlags {
181     ConsumesFlagsReturnsResultWithProducer {
182         inst: MInst,
183         result: Reg,
184     },
185     ConsumesFlagsReturnsReg {
186         inst: MInst,
187         result: Reg,
188     },
189     ConsumesFlagsTwiceReturnsValueRegs {
190         inst1: MInst,
191         inst2: MInst,
192         result: ValueRegs,
193     },
194     ConsumesFlagsFourTimesReturnsValueRegs {
195         inst1: MInst,
196         inst2: MInst,
197         inst3: MInst,
198         inst4: MInst,
199         result: ValueRegs,
200     },
201 }
202 
203 /// Internal type MInst: defined at src/isa/x64/inst.isle line 8.
204 #[derive(Clone)]
205 pub enum MInst {
206     Nop {
207         len: u8,
208     },
209     AluRmiR {
210         size: OperandSize,
211         op: AluRmiROpcode,
212         src1: Gpr,
213         src2: GprMemImm,
214         dst: WritableGpr,
215     },
216     UnaryRmR {
217         size: OperandSize,
218         op: UnaryRmROpcode,
219         src: GprMem,
220         dst: WritableGpr,
221     },
222     Not {
223         size: OperandSize,
224         src: Gpr,
225         dst: WritableGpr,
226     },
227     Neg {
228         size: OperandSize,
229         src: Gpr,
230         dst: WritableGpr,
231     },
232     Div {
233         size: OperandSize,
234         signed: bool,
235         divisor: GprMem,
236         dividend_lo: Gpr,
237         dividend_hi: Gpr,
238         dst_quotient: WritableGpr,
239         dst_remainder: WritableGpr,
240     },
241     MulHi {
242         size: OperandSize,
243         signed: bool,
244         src1: Gpr,
245         src2: GprMem,
246         dst_lo: WritableGpr,
247         dst_hi: WritableGpr,
248     },
249     CheckedDivOrRemSeq {
250         kind: DivOrRemKind,
251         size: OperandSize,
252         dividend_lo: Gpr,
253         dividend_hi: Gpr,
254         divisor: WritableGpr,
255         dst_quotient: WritableGpr,
256         dst_remainder: WritableGpr,
257         tmp: OptionWritableGpr,
258     },
259     SignExtendData {
260         size: OperandSize,
261         src: Gpr,
262         dst: WritableGpr,
263     },
264     Imm {
265         dst_size: OperandSize,
266         simm64: u64,
267         dst: WritableGpr,
268     },
269     MovRR {
270         size: OperandSize,
271         src: Gpr,
272         dst: WritableGpr,
273     },
274     MovzxRmR {
275         ext_mode: ExtMode,
276         src: GprMem,
277         dst: WritableGpr,
278     },
279     Mov64MR {
280         src: SyntheticAmode,
281         dst: WritableGpr,
282     },
283     LoadEffectiveAddress {
284         addr: SyntheticAmode,
285         dst: WritableGpr,
286     },
287     MovsxRmR {
288         ext_mode: ExtMode,
289         src: GprMem,
290         dst: WritableGpr,
291     },
292     MovRM {
293         size: OperandSize,
294         src: Gpr,
295         dst: SyntheticAmode,
296     },
297     ShiftR {
298         size: OperandSize,
299         kind: ShiftKind,
300         src: Gpr,
301         num_bits: Imm8Gpr,
302         dst: WritableGpr,
303     },
304     XmmRmiReg {
305         opcode: SseOpcode,
306         src1: Xmm,
307         src2: XmmMemImm,
308         dst: WritableXmm,
309     },
310     CmpRmiR {
311         size: OperandSize,
312         opcode: CmpOpcode,
313         src: GprMemImm,
314         dst: Gpr,
315     },
316     Setcc {
317         cc: CC,
318         dst: WritableGpr,
319     },
320     Cmove {
321         size: OperandSize,
322         cc: CC,
323         consequent: GprMem,
324         alternative: Gpr,
325         dst: WritableGpr,
326     },
327     XmmCmove {
328         size: OperandSize,
329         cc: CC,
330         consequent: XmmMem,
331         alternative: Xmm,
332         dst: WritableXmm,
333     },
334     Push64 {
335         src: GprMemImm,
336     },
337     Pop64 {
338         dst: WritableGpr,
339     },
340     XmmRmR {
341         op: SseOpcode,
342         src1: Xmm,
343         src2: XmmMem,
344         dst: WritableXmm,
345     },
346     XmmRmREvex {
347         op: Avx512Opcode,
348         src1: XmmMem,
349         src2: Xmm,
350         dst: WritableXmm,
351     },
352     XmmUnaryRmR {
353         op: SseOpcode,
354         src: XmmMem,
355         dst: WritableXmm,
356     },
357     XmmUnaryRmREvex {
358         op: Avx512Opcode,
359         src: XmmMem,
360         dst: WritableXmm,
361     },
362     XmmMovRM {
363         op: SseOpcode,
364         src: Reg,
365         dst: SyntheticAmode,
366     },
367     XmmLoadConst {
368         src: VCodeConstant,
369         dst: WritableReg,
370         ty: Type,
371     },
372     XmmToGpr {
373         op: SseOpcode,
374         src: Xmm,
375         dst: WritableGpr,
376         dst_size: OperandSize,
377     },
378     GprToXmm {
379         op: SseOpcode,
380         src: GprMem,
381         dst: WritableXmm,
382         src_size: OperandSize,
383     },
384     CvtUint64ToFloatSeq {
385         dst_size: OperandSize,
386         src: WritableGpr,
387         dst: WritableXmm,
388         tmp_gpr1: WritableGpr,
389         tmp_gpr2: WritableGpr,
390     },
391     CvtFloatToSintSeq {
392         dst_size: OperandSize,
393         src_size: OperandSize,
394         is_saturating: bool,
395         src: WritableXmm,
396         dst: WritableGpr,
397         tmp_gpr: WritableGpr,
398         tmp_xmm: WritableXmm,
399     },
400     CvtFloatToUintSeq {
401         dst_size: OperandSize,
402         src_size: OperandSize,
403         is_saturating: bool,
404         src: WritableXmm,
405         dst: WritableGpr,
406         tmp_gpr: WritableGpr,
407         tmp_xmm: WritableXmm,
408     },
409     XmmMinMaxSeq {
410         size: OperandSize,
411         is_min: bool,
412         lhs: Xmm,
413         rhs: Xmm,
414         dst: WritableXmm,
415     },
416     XmmCmpRmR {
417         op: SseOpcode,
418         src: XmmMem,
419         dst: Xmm,
420     },
421     XmmRmRImm {
422         op: SseOpcode,
423         src1: Reg,
424         src2: RegMem,
425         dst: WritableReg,
426         imm: u8,
427         size: OperandSize,
428     },
429     CallKnown {
430         dest: ExternalName,
431         uses: VecReg,
432         defs: VecWritableReg,
433         opcode: Opcode,
434     },
435     CallUnknown {
436         dest: RegMem,
437         uses: VecReg,
438         defs: VecWritableReg,
439         opcode: Opcode,
440     },
441     Ret {
442         rets: VecReg,
443     },
444     EpiloguePlaceholder,
445     JmpKnown {
446         dst: MachLabel,
447     },
448     JmpIf {
449         cc: CC,
450         taken: MachLabel,
451     },
452     JmpCond {
453         cc: CC,
454         taken: MachLabel,
455         not_taken: MachLabel,
456     },
457     JmpTableSeq {
458         idx: Reg,
459         tmp1: WritableReg,
460         tmp2: WritableReg,
461         default_target: MachLabel,
462         targets: VecMachLabel,
463         targets_for_term: VecMachLabel,
464     },
465     JmpUnknown {
466         target: RegMem,
467     },
468     TrapIf {
469         cc: CC,
470         trap_code: TrapCode,
471     },
472     Hlt,
473     Ud2 {
474         trap_code: TrapCode,
475     },
476     LoadExtName {
477         dst: WritableReg,
478         name: BoxExternalName,
479         offset: i64,
480     },
481     LockCmpxchg {
482         ty: Type,
483         replacement: Reg,
484         expected: Reg,
485         mem: SyntheticAmode,
486         dst_old: WritableReg,
487     },
488     AtomicRmwSeq {
489         ty: Type,
490         op: AtomicRmwOp,
491         address: Reg,
492         operand: Reg,
493         temp: WritableReg,
494         dst_old: WritableReg,
495     },
496     Fence {
497         kind: FenceKind,
498     },
499     VirtualSPOffsetAdj {
500         offset: i64,
501     },
502     XmmUninitializedValue {
503         dst: WritableXmm,
504     },
505     ElfTlsGetAddr {
506         symbol: ExternalName,
507     },
508     MachOTlsGetAddr {
509         symbol: ExternalName,
510     },
511     Unwind {
512         inst: UnwindInst,
513     },
514     DummyUse {
515         reg: Reg,
516     },
517 }
518 
519 /// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 1202.
520 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
521 pub enum ExtendKind {
522     Sign,
523     Zero,
524 }
525 
526 // Generated as internal constructor for term output_reg.
527 pub fn constructor_output_reg<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
528     let pattern0_0 = arg0;
529     // Rule at src/prelude.isle line 86.
530     let expr0_0 = C::value_reg(ctx, pattern0_0);
531     let expr1_0 = C::output(ctx, expr0_0);
532     return Some(expr1_0);
533 }
534 
535 // Generated as internal constructor for term output_value.
536 pub fn constructor_output_value<C: Context>(ctx: &mut C, arg0: Value) -> Option<InstOutput> {
537     let pattern0_0 = arg0;
538     // Rule at src/prelude.isle line 90.
539     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
540     let expr1_0 = C::output(ctx, expr0_0);
541     return Some(expr1_0);
542 }
543 
544 // Generated as internal constructor for term temp_reg.
545 pub fn constructor_temp_reg<C: Context>(ctx: &mut C, arg0: Type) -> Option<Reg> {
546     let pattern0_0 = arg0;
547     // Rule at src/prelude.isle line 110.
548     let expr0_0 = C::temp_writable_reg(ctx, pattern0_0);
549     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
550     return Some(expr1_0);
551 }
552 
553 // Generated as internal constructor for term lo_reg.
554 pub fn constructor_lo_reg<C: Context>(ctx: &mut C, arg0: Value) -> Option<Reg> {
555     let pattern0_0 = arg0;
556     // Rule at src/prelude.isle line 145.
557     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
558     let expr1_0: usize = 0;
559     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
560     return Some(expr2_0);
561 }
562 
563 // Generated as internal constructor for term side_effect.
564 pub fn constructor_side_effect<C: Context>(
565     ctx: &mut C,
566     arg0: &SideEffectNoResult,
567 ) -> Option<InstOutput> {
568     let pattern0_0 = arg0;
569     if let &SideEffectNoResult::Inst {
570         inst: ref pattern1_0,
571     } = pattern0_0
572     {
573         // Rule at src/prelude.isle line 407.
574         let expr0_0 = C::emit(ctx, pattern1_0);
575         let expr1_0 = C::output_none(ctx);
576         return Some(expr1_0);
577     }
578     return None;
579 }
580 
581 // Generated as internal constructor for term produces_flags_get_reg.
582 pub fn constructor_produces_flags_get_reg<C: Context>(
583     ctx: &mut C,
584     arg0: &ProducesFlags,
585 ) -> Option<Reg> {
586     let pattern0_0 = arg0;
587     if let &ProducesFlags::ProducesFlagsReturnsReg {
588         inst: ref pattern1_0,
589         result: pattern1_1,
590     } = pattern0_0
591     {
592         // Rule at src/prelude.isle line 445.
593         return Some(pattern1_1);
594     }
595     return None;
596 }
597 
598 // Generated as internal constructor for term produces_flags_ignore.
599 pub fn constructor_produces_flags_ignore<C: Context>(
600     ctx: &mut C,
601     arg0: &ProducesFlags,
602 ) -> Option<ProducesFlags> {
603     let pattern0_0 = arg0;
604     match pattern0_0 {
605         &ProducesFlags::ProducesFlagsReturnsReg {
606             inst: ref pattern1_0,
607             result: pattern1_1,
608         } => {
609             // Rule at src/prelude.isle line 450.
610             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
611                 inst: pattern1_0.clone(),
612             };
613             return Some(expr0_0);
614         }
615         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
616             inst: ref pattern1_0,
617             result: pattern1_1,
618         } => {
619             // Rule at src/prelude.isle line 452.
620             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
621                 inst: pattern1_0.clone(),
622             };
623             return Some(expr0_0);
624         }
625         _ => {}
626     }
627     return None;
628 }
629 
630 // Generated as internal constructor for term consumes_flags_concat.
631 pub fn constructor_consumes_flags_concat<C: Context>(
632     ctx: &mut C,
633     arg0: &ConsumesFlags,
634     arg1: &ConsumesFlags,
635 ) -> Option<ConsumesFlags> {
636     let pattern0_0 = arg0;
637     if let &ConsumesFlags::ConsumesFlagsReturnsReg {
638         inst: ref pattern1_0,
639         result: pattern1_1,
640     } = pattern0_0
641     {
642         let pattern2_0 = arg1;
643         if let &ConsumesFlags::ConsumesFlagsReturnsReg {
644             inst: ref pattern3_0,
645             result: pattern3_1,
646         } = pattern2_0
647         {
648             // Rule at src/prelude.isle line 459.
649             let expr0_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
650             let expr1_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
651                 inst1: pattern1_0.clone(),
652                 inst2: pattern3_0.clone(),
653                 result: expr0_0,
654             };
655             return Some(expr1_0);
656         }
657     }
658     return None;
659 }
660 
661 // Generated as internal constructor for term with_flags.
662 pub fn constructor_with_flags<C: Context>(
663     ctx: &mut C,
664     arg0: &ProducesFlags,
665     arg1: &ConsumesFlags,
666 ) -> Option<ValueRegs> {
667     let pattern0_0 = arg0;
668     match pattern0_0 {
669         &ProducesFlags::ProducesFlagsSideEffect {
670             inst: ref pattern1_0,
671         } => {
672             let pattern2_0 = arg1;
673             match pattern2_0 {
674                 &ConsumesFlags::ConsumesFlagsReturnsReg {
675                     inst: ref pattern3_0,
676                     result: pattern3_1,
677                 } => {
678                     // Rule at src/prelude.isle line 484.
679                     let expr0_0 = C::emit(ctx, pattern1_0);
680                     let expr1_0 = C::emit(ctx, pattern3_0);
681                     let expr2_0 = C::value_reg(ctx, pattern3_1);
682                     return Some(expr2_0);
683                 }
684                 &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
685                     inst1: ref pattern3_0,
686                     inst2: ref pattern3_1,
687                     result: pattern3_2,
688                 } => {
689                     // Rule at src/prelude.isle line 490.
690                     let expr0_0 = C::emit(ctx, pattern1_0);
691                     let expr1_0 = C::emit(ctx, pattern3_0);
692                     let expr2_0 = C::emit(ctx, pattern3_1);
693                     return Some(pattern3_2);
694                 }
695                 &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
696                     inst1: ref pattern3_0,
697                     inst2: ref pattern3_1,
698                     inst3: ref pattern3_2,
699                     inst4: ref pattern3_3,
700                     result: pattern3_4,
701                 } => {
702                     // Rule at src/prelude.isle line 502.
703                     let expr0_0 = C::emit(ctx, pattern1_0);
704                     let expr1_0 = C::emit(ctx, pattern3_0);
705                     let expr2_0 = C::emit(ctx, pattern3_1);
706                     let expr3_0 = C::emit(ctx, pattern3_2);
707                     let expr4_0 = C::emit(ctx, pattern3_3);
708                     return Some(pattern3_4);
709                 }
710                 _ => {}
711             }
712         }
713         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
714             inst: ref pattern1_0,
715             result: pattern1_1,
716         } => {
717             let pattern2_0 = arg1;
718             if let &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
719                 inst: ref pattern3_0,
720                 result: pattern3_1,
721             } = pattern2_0
722             {
723                 // Rule at src/prelude.isle line 478.
724                 let expr0_0 = C::emit(ctx, pattern1_0);
725                 let expr1_0 = C::emit(ctx, pattern3_0);
726                 let expr2_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
727                 return Some(expr2_0);
728             }
729         }
730         _ => {}
731     }
732     return None;
733 }
734 
735 // Generated as internal constructor for term with_flags_reg.
736 pub fn constructor_with_flags_reg<C: Context>(
737     ctx: &mut C,
738     arg0: &ProducesFlags,
739     arg1: &ConsumesFlags,
740 ) -> Option<Reg> {
741     let pattern0_0 = arg0;
742     let pattern1_0 = arg1;
743     // Rule at src/prelude.isle line 519.
744     let expr0_0 = constructor_with_flags(ctx, pattern0_0, pattern1_0)?;
745     let expr1_0: usize = 0;
746     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
747     return Some(expr2_0);
748 }
749 
750 // Generated as internal constructor for term operand_size_bits.
751 pub fn constructor_operand_size_bits<C: Context>(ctx: &mut C, arg0: &OperandSize) -> Option<u16> {
752     let pattern0_0 = arg0;
753     match pattern0_0 {
754         &OperandSize::Size8 => {
755             // Rule at src/isa/x64/inst.isle line 511.
756             let expr0_0: u16 = 8;
757             return Some(expr0_0);
758         }
759         &OperandSize::Size16 => {
760             // Rule at src/isa/x64/inst.isle line 512.
761             let expr0_0: u16 = 16;
762             return Some(expr0_0);
763         }
764         &OperandSize::Size32 => {
765             // Rule at src/isa/x64/inst.isle line 513.
766             let expr0_0: u16 = 32;
767             return Some(expr0_0);
768         }
769         &OperandSize::Size64 => {
770             // Rule at src/isa/x64/inst.isle line 514.
771             let expr0_0: u16 = 64;
772             return Some(expr0_0);
773         }
774         _ => {}
775     }
776     return None;
777 }
778 
779 // Generated as internal constructor for term amode_imm_reg_flags.
780 pub fn constructor_amode_imm_reg_flags<C: Context>(
781     ctx: &mut C,
782     arg0: u32,
783     arg1: Gpr,
784     arg2: MemFlags,
785 ) -> Option<Amode> {
786     let pattern0_0 = arg0;
787     let pattern1_0 = arg1;
788     let pattern2_0 = arg2;
789     // Rule at src/isa/x64/inst.isle line 771.
790     let expr0_0 = C::amode_imm_reg(ctx, pattern0_0, pattern1_0);
791     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern2_0);
792     return Some(expr1_0);
793 }
794 
795 // Generated as internal constructor for term amode_imm_reg_reg_shift_flags.
796 pub fn constructor_amode_imm_reg_reg_shift_flags<C: Context>(
797     ctx: &mut C,
798     arg0: u32,
799     arg1: Gpr,
800     arg2: Gpr,
801     arg3: u8,
802     arg4: MemFlags,
803 ) -> Option<Amode> {
804     let pattern0_0 = arg0;
805     let pattern1_0 = arg1;
806     let pattern2_0 = arg2;
807     let pattern3_0 = arg3;
808     let pattern4_0 = arg4;
809     // Rule at src/isa/x64/inst.isle line 778.
810     let expr0_0 = C::amode_imm_reg_reg_shift(ctx, pattern0_0, pattern1_0, pattern2_0, pattern3_0);
811     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern4_0);
812     return Some(expr1_0);
813 }
814 
815 // Generated as internal constructor for term to_amode.
816 pub fn constructor_to_amode<C: Context>(
817     ctx: &mut C,
818     arg0: MemFlags,
819     arg1: Value,
820     arg2: Offset32,
821 ) -> Option<Amode> {
822     let pattern0_0 = arg0;
823     let pattern1_0 = arg1;
824     if let Some(pattern2_0) = C::def_inst(ctx, pattern1_0) {
825         let pattern3_0 = C::inst_data(ctx, pattern2_0);
826         if let &InstructionData::Binary {
827             opcode: ref pattern4_0,
828             args: ref pattern4_1,
829         } = &pattern3_0
830         {
831             if let &Opcode::Iadd = pattern4_0 {
832                 let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
833                 if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) {
834                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
835                     match &pattern8_0 {
836                         &InstructionData::UnaryImm {
837                             opcode: ref pattern9_0,
838                             imm: pattern9_1,
839                         } => {
840                             if let &Opcode::Iconst = pattern9_0 {
841                                 let pattern11_0 = arg2;
842                                 let closure12 = || {
843                                     let expr0_0: Type = I64;
844                                     return Some(expr0_0);
845                                 };
846                                 if let Some(pattern12_0) = closure12() {
847                                     let closure13 = || {
848                                         return Some(pattern9_1);
849                                     };
850                                     if let Some(pattern13_0) = closure13() {
851                                         if let Some(pattern14_0) = C::sum_extend_fits_in_32_bits(
852                                             ctx,
853                                             pattern11_0,
854                                             pattern12_0,
855                                             pattern13_0,
856                                         ) {
857                                             // Rule at src/isa/x64/inst.isle line 825.
858                                             let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
859                                             let expr1_0 = constructor_amode_imm_reg_flags(
860                                                 ctx,
861                                                 pattern14_0,
862                                                 expr0_0,
863                                                 pattern0_0,
864                                             )?;
865                                             return Some(expr1_0);
866                                         }
867                                     }
868                                 }
869                             }
870                         }
871                         &InstructionData::Binary {
872                             opcode: ref pattern9_0,
873                             args: ref pattern9_1,
874                         } => {
875                             if let &Opcode::Ishl = pattern9_0 {
876                                 let (pattern11_0, pattern11_1) =
877                                     C::unpack_value_array_2(ctx, pattern9_1);
878                                 if let Some(pattern12_0) = C::const_shift_lt_eq_3(ctx, pattern11_1)
879                                 {
880                                     let pattern13_0 = arg2;
881                                     // Rule at src/isa/x64/inst.isle line 817.
882                                     let expr0_0 = C::offset32_to_u32(ctx, pattern13_0);
883                                     let expr1_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
884                                     let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
885                                     let expr3_0 = constructor_amode_imm_reg_reg_shift_flags(
886                                         ctx,
887                                         expr0_0,
888                                         expr1_0,
889                                         expr2_0,
890                                         pattern12_0,
891                                         pattern0_0,
892                                     )?;
893                                     return Some(expr3_0);
894                                 }
895                             }
896                         }
897                         _ => {}
898                     }
899                     if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
900                         let pattern9_0 = C::value_type(ctx, pattern8_0);
901                         let pattern10_0 = C::inst_data(ctx, pattern7_0);
902                         if let &InstructionData::Unary {
903                             opcode: ref pattern11_0,
904                             arg: pattern11_1,
905                         } = &pattern10_0
906                         {
907                             if let &Opcode::Uextend = pattern11_0 {
908                                 if let Some(pattern13_0) = C::def_inst(ctx, pattern11_1) {
909                                     let pattern14_0 = C::inst_data(ctx, pattern13_0);
910                                     if let &InstructionData::UnaryImm {
911                                         opcode: ref pattern15_0,
912                                         imm: pattern15_1,
913                                     } = &pattern14_0
914                                     {
915                                         if let &Opcode::Iconst = pattern15_0 {
916                                             let pattern17_0 = arg2;
917                                             let closure18 = || {
918                                                 return Some(pattern9_0);
919                                             };
920                                             if let Some(pattern18_0) = closure18() {
921                                                 let closure19 = || {
922                                                     return Some(pattern15_1);
923                                                 };
924                                                 if let Some(pattern19_0) = closure19() {
925                                                     if let Some(pattern20_0) =
926                                                         C::sum_extend_fits_in_32_bits(
927                                                             ctx,
928                                                             pattern17_0,
929                                                             pattern18_0,
930                                                             pattern19_0,
931                                                         )
932                                                     {
933                                                         // Rule at src/isa/x64/inst.isle line 830.
934                                                         let expr0_0 = constructor_put_in_gpr(
935                                                             ctx, pattern6_1,
936                                                         )?;
937                                                         let expr1_0 =
938                                                             constructor_amode_imm_reg_flags(
939                                                                 ctx,
940                                                                 pattern20_0,
941                                                                 expr0_0,
942                                                                 pattern0_0,
943                                                             )?;
944                                                         return Some(expr1_0);
945                                                     }
946                                                 }
947                                             }
948                                         }
949                                     }
950                                 }
951                             }
952                         }
953                     }
954                 }
955                 if let Some(pattern7_0) = C::def_inst(ctx, pattern6_1) {
956                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
957                     match &pattern8_0 {
958                         &InstructionData::UnaryImm {
959                             opcode: ref pattern9_0,
960                             imm: pattern9_1,
961                         } => {
962                             if let &Opcode::Iconst = pattern9_0 {
963                                 let pattern11_0 = arg2;
964                                 let closure12 = || {
965                                     let expr0_0: Type = I64;
966                                     return Some(expr0_0);
967                                 };
968                                 if let Some(pattern12_0) = closure12() {
969                                     let closure13 = || {
970                                         return Some(pattern9_1);
971                                     };
972                                     if let Some(pattern13_0) = closure13() {
973                                         if let Some(pattern14_0) = C::sum_extend_fits_in_32_bits(
974                                             ctx,
975                                             pattern11_0,
976                                             pattern12_0,
977                                             pattern13_0,
978                                         ) {
979                                             // Rule at src/isa/x64/inst.isle line 827.
980                                             let expr0_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
981                                             let expr1_0 = constructor_amode_imm_reg_flags(
982                                                 ctx,
983                                                 pattern14_0,
984                                                 expr0_0,
985                                                 pattern0_0,
986                                             )?;
987                                             return Some(expr1_0);
988                                         }
989                                     }
990                                 }
991                             }
992                         }
993                         &InstructionData::Binary {
994                             opcode: ref pattern9_0,
995                             args: ref pattern9_1,
996                         } => {
997                             if let &Opcode::Ishl = pattern9_0 {
998                                 let (pattern11_0, pattern11_1) =
999                                     C::unpack_value_array_2(ctx, pattern9_1);
1000                                 if let Some(pattern12_0) = C::const_shift_lt_eq_3(ctx, pattern11_1)
1001                                 {
1002                                     let pattern13_0 = arg2;
1003                                     // Rule at src/isa/x64/inst.isle line 819.
1004                                     let expr0_0 = C::offset32_to_u32(ctx, pattern13_0);
1005                                     let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
1006                                     let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
1007                                     let expr3_0 = constructor_amode_imm_reg_reg_shift_flags(
1008                                         ctx,
1009                                         expr0_0,
1010                                         expr1_0,
1011                                         expr2_0,
1012                                         pattern12_0,
1013                                         pattern0_0,
1014                                     )?;
1015                                     return Some(expr3_0);
1016                                 }
1017                             }
1018                         }
1019                         _ => {}
1020                     }
1021                     if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
1022                         let pattern9_0 = C::value_type(ctx, pattern8_0);
1023                         let pattern10_0 = C::inst_data(ctx, pattern7_0);
1024                         if let &InstructionData::Unary {
1025                             opcode: ref pattern11_0,
1026                             arg: pattern11_1,
1027                         } = &pattern10_0
1028                         {
1029                             if let &Opcode::Uextend = pattern11_0 {
1030                                 if let Some(pattern13_0) = C::def_inst(ctx, pattern11_1) {
1031                                     let pattern14_0 = C::inst_data(ctx, pattern13_0);
1032                                     if let &InstructionData::UnaryImm {
1033                                         opcode: ref pattern15_0,
1034                                         imm: pattern15_1,
1035                                     } = &pattern14_0
1036                                     {
1037                                         if let &Opcode::Iconst = pattern15_0 {
1038                                             let pattern17_0 = arg2;
1039                                             let closure18 = || {
1040                                                 return Some(pattern9_0);
1041                                             };
1042                                             if let Some(pattern18_0) = closure18() {
1043                                                 let closure19 = || {
1044                                                     return Some(pattern15_1);
1045                                                 };
1046                                                 if let Some(pattern19_0) = closure19() {
1047                                                     if let Some(pattern20_0) =
1048                                                         C::sum_extend_fits_in_32_bits(
1049                                                             ctx,
1050                                                             pattern17_0,
1051                                                             pattern18_0,
1052                                                             pattern19_0,
1053                                                         )
1054                                                     {
1055                                                         // Rule at src/isa/x64/inst.isle line 832.
1056                                                         let expr0_0 = constructor_put_in_gpr(
1057                                                             ctx, pattern6_0,
1058                                                         )?;
1059                                                         let expr1_0 =
1060                                                             constructor_amode_imm_reg_flags(
1061                                                                 ctx,
1062                                                                 pattern20_0,
1063                                                                 expr0_0,
1064                                                                 pattern0_0,
1065                                                             )?;
1066                                                         return Some(expr1_0);
1067                                                     }
1068                                                 }
1069                                             }
1070                                         }
1071                                     }
1072                                 }
1073                             }
1074                         }
1075                     }
1076                 }
1077                 let pattern7_0 = arg2;
1078                 // Rule at src/isa/x64/inst.isle line 835.
1079                 let expr0_0 = C::offset32_to_u32(ctx, pattern7_0);
1080                 let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
1081                 let expr2_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
1082                 let expr3_0: u8 = 0;
1083                 let expr4_0 = constructor_amode_imm_reg_reg_shift_flags(
1084                     ctx, expr0_0, expr1_0, expr2_0, expr3_0, pattern0_0,
1085                 )?;
1086                 return Some(expr4_0);
1087             }
1088         }
1089     }
1090     let pattern2_0 = arg2;
1091     // Rule at src/isa/x64/inst.isle line 838.
1092     let expr0_0 = C::offset32_to_u32(ctx, pattern2_0);
1093     let expr1_0 = constructor_put_in_gpr(ctx, pattern1_0)?;
1094     let expr2_0 = constructor_amode_imm_reg_flags(ctx, expr0_0, expr1_0, pattern0_0)?;
1095     return Some(expr2_0);
1096 }
1097 
1098 // Generated as internal constructor for term reg_to_gpr_mem_imm.
1099 pub fn constructor_reg_to_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Reg) -> Option<GprMemImm> {
1100     let pattern0_0 = arg0;
1101     // Rule at src/isa/x64/inst.isle line 1032.
1102     let expr0_0 = C::gpr_new(ctx, pattern0_0);
1103     let expr1_0 = C::gpr_to_gpr_mem_imm(ctx, expr0_0);
1104     return Some(expr1_0);
1105 }
1106 
1107 // Generated as internal constructor for term put_in_gpr.
1108 pub fn constructor_put_in_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1109     let pattern0_0 = arg0;
1110     // Rule at src/isa/x64/inst.isle line 1039.
1111     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1112     let expr1_0 = C::gpr_new(ctx, expr0_0);
1113     return Some(expr1_0);
1114 }
1115 
1116 // Generated as internal constructor for term put_in_gpr_mem.
1117 pub fn constructor_put_in_gpr_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMem> {
1118     let pattern0_0 = arg0;
1119     // Rule at src/isa/x64/inst.isle line 1046.
1120     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1121     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
1122     return Some(expr1_0);
1123 }
1124 
1125 // Generated as internal constructor for term put_in_gpr_mem_imm.
1126 pub fn constructor_put_in_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMemImm> {
1127     let pattern0_0 = arg0;
1128     // Rule at src/isa/x64/inst.isle line 1053.
1129     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1130     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1131     return Some(expr1_0);
1132 }
1133 
1134 // Generated as internal constructor for term put_in_xmm.
1135 pub fn constructor_put_in_xmm<C: Context>(ctx: &mut C, arg0: Value) -> Option<Xmm> {
1136     let pattern0_0 = arg0;
1137     // Rule at src/isa/x64/inst.isle line 1060.
1138     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1139     let expr1_0 = C::xmm_new(ctx, expr0_0);
1140     return Some(expr1_0);
1141 }
1142 
1143 // Generated as internal constructor for term put_in_xmm_mem.
1144 pub fn constructor_put_in_xmm_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMem> {
1145     let pattern0_0 = arg0;
1146     // Rule at src/isa/x64/inst.isle line 1067.
1147     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1148     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
1149     return Some(expr1_0);
1150 }
1151 
1152 // Generated as internal constructor for term put_in_xmm_mem_imm.
1153 pub fn constructor_put_in_xmm_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMemImm> {
1154     let pattern0_0 = arg0;
1155     // Rule at src/isa/x64/inst.isle line 1074.
1156     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1157     let expr1_0 = C::xmm_mem_imm_new(ctx, &expr0_0);
1158     return Some(expr1_0);
1159 }
1160 
1161 // Generated as internal constructor for term output_gpr.
1162 pub fn constructor_output_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<InstOutput> {
1163     let pattern0_0 = arg0;
1164     // Rule at src/isa/x64/inst.isle line 1079.
1165     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1166     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1167     return Some(expr1_0);
1168 }
1169 
1170 // Generated as internal constructor for term value_gprs.
1171 pub fn constructor_value_gprs<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> Option<ValueRegs> {
1172     let pattern0_0 = arg0;
1173     let pattern1_0 = arg1;
1174     // Rule at src/isa/x64/inst.isle line 1084.
1175     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1176     let expr1_0 = C::gpr_to_reg(ctx, pattern1_0);
1177     let expr2_0 = C::value_regs(ctx, expr0_0, expr1_0);
1178     return Some(expr2_0);
1179 }
1180 
1181 // Generated as internal constructor for term output_xmm.
1182 pub fn constructor_output_xmm<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<InstOutput> {
1183     let pattern0_0 = arg0;
1184     // Rule at src/isa/x64/inst.isle line 1089.
1185     let expr0_0 = C::xmm_to_reg(ctx, pattern0_0);
1186     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1187     return Some(expr1_0);
1188 }
1189 
1190 // Generated as internal constructor for term value_regs_get_gpr.
1191 pub fn constructor_value_regs_get_gpr<C: Context>(
1192     ctx: &mut C,
1193     arg0: ValueRegs,
1194     arg1: usize,
1195 ) -> Option<Gpr> {
1196     let pattern0_0 = arg0;
1197     let pattern1_0 = arg1;
1198     // Rule at src/isa/x64/inst.isle line 1096.
1199     let expr0_0 = C::value_regs_get(ctx, pattern0_0, pattern1_0);
1200     let expr1_0 = C::gpr_new(ctx, expr0_0);
1201     return Some(expr1_0);
1202 }
1203 
1204 // Generated as internal constructor for term lo_gpr.
1205 pub fn constructor_lo_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1206     let pattern0_0 = arg0;
1207     // Rule at src/isa/x64/inst.isle line 1109.
1208     let expr0_0 = constructor_lo_reg(ctx, pattern0_0)?;
1209     let expr1_0 = C::gpr_new(ctx, expr0_0);
1210     return Some(expr1_0);
1211 }
1212 
1213 // Generated as internal constructor for term sink_load_to_gpr_mem_imm.
1214 pub fn constructor_sink_load_to_gpr_mem_imm<C: Context>(
1215     ctx: &mut C,
1216     arg0: &SinkableLoad,
1217 ) -> Option<GprMemImm> {
1218     let pattern0_0 = arg0;
1219     // Rule at src/isa/x64/inst.isle line 1192.
1220     let expr0_0 = C::sink_load(ctx, pattern0_0);
1221     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1222     return Some(expr1_0);
1223 }
1224 
1225 // Generated as internal constructor for term extend_to_gpr.
1226 pub fn constructor_extend_to_gpr<C: Context>(
1227     ctx: &mut C,
1228     arg0: Value,
1229     arg1: Type,
1230     arg2: &ExtendKind,
1231 ) -> Option<Gpr> {
1232     let pattern0_0 = arg0;
1233     let pattern1_0 = C::value_type(ctx, pattern0_0);
1234     let pattern2_0 = arg1;
1235     if pattern2_0 == pattern1_0 {
1236         let pattern4_0 = arg2;
1237         // Rule at src/isa/x64/inst.isle line 1214.
1238         let expr0_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
1239         return Some(expr0_0);
1240     }
1241     let pattern3_0 = arg2;
1242     // Rule at src/isa/x64/inst.isle line 1217.
1243     let expr0_0 = C::ty_bits_u16(ctx, pattern1_0);
1244     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern2_0);
1245     let expr2_0 = constructor_operand_size_bits(ctx, &expr1_0)?;
1246     let expr3_0 = C::ext_mode(ctx, expr0_0, expr2_0);
1247     let expr4_0 = constructor_put_in_gpr_mem(ctx, pattern0_0)?;
1248     let expr5_0 = constructor_extend(ctx, pattern3_0, pattern2_0, &expr3_0, &expr4_0)?;
1249     return Some(expr5_0);
1250 }
1251 
1252 // Generated as internal constructor for term extend.
1253 pub fn constructor_extend<C: Context>(
1254     ctx: &mut C,
1255     arg0: &ExtendKind,
1256     arg1: Type,
1257     arg2: &ExtMode,
1258     arg3: &GprMem,
1259 ) -> Option<Gpr> {
1260     let pattern0_0 = arg0;
1261     match pattern0_0 {
1262         &ExtendKind::Sign => {
1263             let pattern2_0 = arg1;
1264             let pattern3_0 = arg2;
1265             let pattern4_0 = arg3;
1266             // Rule at src/isa/x64/inst.isle line 1237.
1267             let expr0_0 = constructor_x64_movsx(ctx, pattern3_0, pattern4_0)?;
1268             return Some(expr0_0);
1269         }
1270         &ExtendKind::Zero => {
1271             let pattern2_0 = arg1;
1272             let pattern3_0 = arg2;
1273             let pattern4_0 = arg3;
1274             // Rule at src/isa/x64/inst.isle line 1233.
1275             let expr0_0 = constructor_x64_movzx(ctx, pattern3_0, pattern4_0)?;
1276             return Some(expr0_0);
1277         }
1278         _ => {}
1279     }
1280     return None;
1281 }
1282 
1283 // Generated as internal constructor for term sse_xor_op.
1284 pub fn constructor_sse_xor_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1285     let pattern0_0 = arg0;
1286     if pattern0_0 == F32X4 {
1287         // Rule at src/isa/x64/inst.isle line 1244.
1288         let expr0_0 = SseOpcode::Xorps;
1289         return Some(expr0_0);
1290     }
1291     if pattern0_0 == F64X2 {
1292         // Rule at src/isa/x64/inst.isle line 1245.
1293         let expr0_0 = SseOpcode::Xorpd;
1294         return Some(expr0_0);
1295     }
1296     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1297         // Rule at src/isa/x64/inst.isle line 1246.
1298         let expr0_0 = SseOpcode::Pxor;
1299         return Some(expr0_0);
1300     }
1301     return None;
1302 }
1303 
1304 // Generated as internal constructor for term sse_xor.
1305 pub fn constructor_sse_xor<C: Context>(
1306     ctx: &mut C,
1307     arg0: Type,
1308     arg1: Xmm,
1309     arg2: &XmmMem,
1310 ) -> Option<Xmm> {
1311     let pattern0_0 = arg0;
1312     let pattern1_0 = arg1;
1313     let pattern2_0 = arg2;
1314     // Rule at src/isa/x64/inst.isle line 1250.
1315     let expr0_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
1316     let expr1_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1317     return Some(expr1_0);
1318 }
1319 
1320 // Generated as internal constructor for term sse_cmp_op.
1321 pub fn constructor_sse_cmp_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1322     let pattern0_0 = arg0;
1323     if pattern0_0 == F32X4 {
1324         // Rule at src/isa/x64/inst.isle line 1259.
1325         let expr0_0 = SseOpcode::Cmpps;
1326         return Some(expr0_0);
1327     }
1328     if pattern0_0 == F64X2 {
1329         // Rule at src/isa/x64/inst.isle line 1260.
1330         let expr0_0 = SseOpcode::Cmppd;
1331         return Some(expr0_0);
1332     }
1333     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1334         if pattern1_0 == 8 {
1335             if pattern1_1 == 16 {
1336                 // Rule at src/isa/x64/inst.isle line 1255.
1337                 let expr0_0 = SseOpcode::Pcmpeqb;
1338                 return Some(expr0_0);
1339             }
1340         }
1341         if pattern1_0 == 16 {
1342             if pattern1_1 == 8 {
1343                 // Rule at src/isa/x64/inst.isle line 1256.
1344                 let expr0_0 = SseOpcode::Pcmpeqw;
1345                 return Some(expr0_0);
1346             }
1347         }
1348         if pattern1_0 == 32 {
1349             if pattern1_1 == 4 {
1350                 // Rule at src/isa/x64/inst.isle line 1257.
1351                 let expr0_0 = SseOpcode::Pcmpeqd;
1352                 return Some(expr0_0);
1353             }
1354         }
1355         if pattern1_0 == 64 {
1356             if pattern1_1 == 2 {
1357                 // Rule at src/isa/x64/inst.isle line 1258.
1358                 let expr0_0 = SseOpcode::Pcmpeqq;
1359                 return Some(expr0_0);
1360             }
1361         }
1362     }
1363     return None;
1364 }
1365 
1366 // Generated as internal constructor for term vector_all_ones.
1367 pub fn constructor_vector_all_ones<C: Context>(ctx: &mut C, arg0: Type) -> Option<Xmm> {
1368     let pattern0_0 = arg0;
1369     // Rule at src/isa/x64/inst.isle line 1274.
1370     let expr0_0 = C::temp_writable_xmm(ctx);
1371     let expr1_0: Type = I32X4;
1372     let expr2_0 = constructor_sse_cmp_op(ctx, expr1_0)?;
1373     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1374     let expr4_0 = constructor_writable_xmm_to_xmm_mem(ctx, expr0_0)?;
1375     let expr5_0 = MInst::XmmRmR {
1376         op: expr2_0,
1377         src1: expr3_0,
1378         src2: expr4_0,
1379         dst: expr0_0,
1380     };
1381     let expr6_0 = C::emit(ctx, &expr5_0);
1382     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1383     return Some(expr7_0);
1384 }
1385 
1386 // Generated as internal constructor for term make_i64x2_from_lanes.
1387 pub fn constructor_make_i64x2_from_lanes<C: Context>(
1388     ctx: &mut C,
1389     arg0: &GprMem,
1390     arg1: &GprMem,
1391 ) -> Option<Xmm> {
1392     let pattern0_0 = arg0;
1393     let pattern1_0 = arg1;
1394     // Rule at src/isa/x64/inst.isle line 1284.
1395     let expr0_0 = C::temp_writable_xmm(ctx);
1396     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
1397     let expr2_0 = MInst::XmmUninitializedValue { dst: expr0_0 };
1398     let expr3_0 = C::emit(ctx, &expr2_0);
1399     let expr4_0 = SseOpcode::Pinsrd;
1400     let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0);
1401     let expr6_0 = C::gpr_mem_to_reg_mem(ctx, pattern0_0);
1402     let expr7_0: u8 = 0;
1403     let expr8_0 = OperandSize::Size64;
1404     let expr9_0 = MInst::XmmRmRImm {
1405         op: expr4_0,
1406         src1: expr5_0,
1407         src2: expr6_0,
1408         dst: expr1_0,
1409         imm: expr7_0,
1410         size: expr8_0,
1411     };
1412     let expr10_0 = C::emit(ctx, &expr9_0);
1413     let expr11_0 = SseOpcode::Pinsrd;
1414     let expr12_0 = C::writable_reg_to_reg(ctx, expr1_0);
1415     let expr13_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
1416     let expr14_0: u8 = 1;
1417     let expr15_0 = OperandSize::Size64;
1418     let expr16_0 = MInst::XmmRmRImm {
1419         op: expr11_0,
1420         src1: expr12_0,
1421         src2: expr13_0,
1422         dst: expr1_0,
1423         imm: expr14_0,
1424         size: expr15_0,
1425     };
1426     let expr17_0 = C::emit(ctx, &expr16_0);
1427     let expr18_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1428     return Some(expr18_0);
1429 }
1430 
1431 // Generated as internal constructor for term mov_rmi_to_xmm.
1432 pub fn constructor_mov_rmi_to_xmm<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> Option<XmmMemImm> {
1433     let pattern0_0 = arg0;
1434     match pattern0_0 {
1435         &RegMemImm::Imm { simm32: pattern1_0 } => {
1436             // Rule at src/isa/x64/inst.isle line 1305.
1437             let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0);
1438             return Some(expr0_0);
1439         }
1440         &RegMemImm::Reg { reg: pattern1_0 } => {
1441             // Rule at src/isa/x64/inst.isle line 1306.
1442             let expr0_0 = SseOpcode::Movd;
1443             let expr1_0 = C::reg_to_gpr_mem(ctx, pattern1_0);
1444             let expr2_0 = OperandSize::Size32;
1445             let expr3_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr1_0, &expr2_0)?;
1446             let expr4_0 = C::xmm_to_xmm_mem_imm(ctx, expr3_0);
1447             return Some(expr4_0);
1448         }
1449         &RegMemImm::Mem {
1450             addr: ref pattern1_0,
1451         } => {
1452             // Rule at src/isa/x64/inst.isle line 1304.
1453             let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0);
1454             return Some(expr0_0);
1455         }
1456         _ => {}
1457     }
1458     return None;
1459 }
1460 
1461 // Generated as internal constructor for term x64_load.
1462 pub fn constructor_x64_load<C: Context>(
1463     ctx: &mut C,
1464     arg0: Type,
1465     arg1: &SyntheticAmode,
1466     arg2: &ExtKind,
1467 ) -> Option<Reg> {
1468     let pattern0_0 = arg0;
1469     if pattern0_0 == I64 {
1470         let pattern2_0 = arg1;
1471         let pattern3_0 = arg2;
1472         // Rule at src/isa/x64/inst.isle line 1320.
1473         let expr0_0 = C::temp_writable_gpr(ctx);
1474         let expr1_0 = MInst::Mov64MR {
1475             src: pattern2_0.clone(),
1476             dst: expr0_0,
1477         };
1478         let expr2_0 = C::emit(ctx, &expr1_0);
1479         let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1480         return Some(expr3_0);
1481     }
1482     if pattern0_0 == F32 {
1483         let pattern2_0 = arg1;
1484         let pattern3_0 = arg2;
1485         // Rule at src/isa/x64/inst.isle line 1325.
1486         let expr0_0 = SseOpcode::Movss;
1487         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1488         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1489         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1490         return Some(expr3_0);
1491     }
1492     if pattern0_0 == F64 {
1493         let pattern2_0 = arg1;
1494         let pattern3_0 = arg2;
1495         // Rule at src/isa/x64/inst.isle line 1329.
1496         let expr0_0 = SseOpcode::Movsd;
1497         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1498         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1499         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1500         return Some(expr3_0);
1501     }
1502     if pattern0_0 == F32X4 {
1503         let pattern2_0 = arg1;
1504         let pattern3_0 = arg2;
1505         // Rule at src/isa/x64/inst.isle line 1333.
1506         let expr0_0 = SseOpcode::Movups;
1507         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1508         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1509         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1510         return Some(expr3_0);
1511     }
1512     if pattern0_0 == F64X2 {
1513         let pattern2_0 = arg1;
1514         let pattern3_0 = arg2;
1515         // Rule at src/isa/x64/inst.isle line 1337.
1516         let expr0_0 = SseOpcode::Movupd;
1517         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1518         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1519         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1520         return Some(expr3_0);
1521     }
1522     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1523         let pattern2_0 = arg1;
1524         let pattern3_0 = arg2;
1525         // Rule at src/isa/x64/inst.isle line 1341.
1526         let expr0_0 = SseOpcode::Movdqu;
1527         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1528         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1529         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1530         return Some(expr3_0);
1531     }
1532     if let Some(pattern1_0) = C::fits_in_32(ctx, pattern0_0) {
1533         let pattern2_0 = arg1;
1534         let pattern3_0 = arg2;
1535         if let &ExtKind::SignExtend = pattern3_0 {
1536             // Rule at src/isa/x64/inst.isle line 1316.
1537             let expr0_0 = C::ty_bytes(ctx, pattern1_0);
1538             let expr1_0: u16 = 8;
1539             let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
1540             let expr3_0 = constructor_synthetic_amode_to_gpr_mem(ctx, pattern2_0)?;
1541             let expr4_0 = constructor_x64_movsx(ctx, &expr2_0, &expr3_0)?;
1542             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
1543             return Some(expr5_0);
1544         }
1545     }
1546     return None;
1547 }
1548 
1549 // Generated as internal constructor for term x64_mov.
1550 pub fn constructor_x64_mov<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<Reg> {
1551     let pattern0_0 = arg0;
1552     // Rule at src/isa/x64/inst.isle line 1346.
1553     let expr0_0 = C::temp_writable_gpr(ctx);
1554     let expr1_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
1555     let expr2_0 = MInst::Mov64MR {
1556         src: expr1_0,
1557         dst: expr0_0,
1558     };
1559     let expr3_0 = C::emit(ctx, &expr2_0);
1560     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1561     return Some(expr4_0);
1562 }
1563 
1564 // Generated as internal constructor for term x64_movzx.
1565 pub fn constructor_x64_movzx<C: Context>(
1566     ctx: &mut C,
1567     arg0: &ExtMode,
1568     arg1: &GprMem,
1569 ) -> Option<Gpr> {
1570     let pattern0_0 = arg0;
1571     let pattern1_0 = arg1;
1572     // Rule at src/isa/x64/inst.isle line 1352.
1573     let expr0_0 = C::temp_writable_gpr(ctx);
1574     let expr1_0 = MInst::MovzxRmR {
1575         ext_mode: pattern0_0.clone(),
1576         src: pattern1_0.clone(),
1577         dst: expr0_0,
1578     };
1579     let expr2_0 = C::emit(ctx, &expr1_0);
1580     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1581     return Some(expr3_0);
1582 }
1583 
1584 // Generated as internal constructor for term x64_movsx.
1585 pub fn constructor_x64_movsx<C: Context>(
1586     ctx: &mut C,
1587     arg0: &ExtMode,
1588     arg1: &GprMem,
1589 ) -> Option<Gpr> {
1590     let pattern0_0 = arg0;
1591     let pattern1_0 = arg1;
1592     // Rule at src/isa/x64/inst.isle line 1358.
1593     let expr0_0 = C::temp_writable_gpr(ctx);
1594     let expr1_0 = MInst::MovsxRmR {
1595         ext_mode: pattern0_0.clone(),
1596         src: pattern1_0.clone(),
1597         dst: expr0_0,
1598     };
1599     let expr2_0 = C::emit(ctx, &expr1_0);
1600     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1601     return Some(expr3_0);
1602 }
1603 
1604 // Generated as internal constructor for term x64_movss_load.
1605 pub fn constructor_x64_movss_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1606     let pattern0_0 = arg0;
1607     // Rule at src/isa/x64/inst.isle line 1364.
1608     let expr0_0 = SseOpcode::Movss;
1609     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1610     return Some(expr1_0);
1611 }
1612 
1613 // Generated as internal constructor for term x64_movsd_load.
1614 pub fn constructor_x64_movsd_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1615     let pattern0_0 = arg0;
1616     // Rule at src/isa/x64/inst.isle line 1368.
1617     let expr0_0 = SseOpcode::Movsd;
1618     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1619     return Some(expr1_0);
1620 }
1621 
1622 // Generated as internal constructor for term x64_movups.
1623 pub fn constructor_x64_movups<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1624     let pattern0_0 = arg0;
1625     // Rule at src/isa/x64/inst.isle line 1372.
1626     let expr0_0 = SseOpcode::Movups;
1627     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1628     return Some(expr1_0);
1629 }
1630 
1631 // Generated as internal constructor for term x64_movupd.
1632 pub fn constructor_x64_movupd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1633     let pattern0_0 = arg0;
1634     // Rule at src/isa/x64/inst.isle line 1376.
1635     let expr0_0 = SseOpcode::Movupd;
1636     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1637     return Some(expr1_0);
1638 }
1639 
1640 // Generated as internal constructor for term x64_movdqu.
1641 pub fn constructor_x64_movdqu<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1642     let pattern0_0 = arg0;
1643     // Rule at src/isa/x64/inst.isle line 1380.
1644     let expr0_0 = SseOpcode::Movdqu;
1645     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1646     return Some(expr1_0);
1647 }
1648 
1649 // Generated as internal constructor for term x64_pmovsxbw.
1650 pub fn constructor_x64_pmovsxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1651     let pattern0_0 = arg0;
1652     // Rule at src/isa/x64/inst.isle line 1384.
1653     let expr0_0 = SseOpcode::Pmovsxbw;
1654     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1655     return Some(expr1_0);
1656 }
1657 
1658 // Generated as internal constructor for term x64_pmovzxbw.
1659 pub fn constructor_x64_pmovzxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1660     let pattern0_0 = arg0;
1661     // Rule at src/isa/x64/inst.isle line 1388.
1662     let expr0_0 = SseOpcode::Pmovzxbw;
1663     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1664     return Some(expr1_0);
1665 }
1666 
1667 // Generated as internal constructor for term x64_pmovsxwd.
1668 pub fn constructor_x64_pmovsxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1669     let pattern0_0 = arg0;
1670     // Rule at src/isa/x64/inst.isle line 1392.
1671     let expr0_0 = SseOpcode::Pmovsxwd;
1672     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1673     return Some(expr1_0);
1674 }
1675 
1676 // Generated as internal constructor for term x64_pmovzxwd.
1677 pub fn constructor_x64_pmovzxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1678     let pattern0_0 = arg0;
1679     // Rule at src/isa/x64/inst.isle line 1396.
1680     let expr0_0 = SseOpcode::Pmovzxwd;
1681     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1682     return Some(expr1_0);
1683 }
1684 
1685 // Generated as internal constructor for term x64_pmovsxdq.
1686 pub fn constructor_x64_pmovsxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1687     let pattern0_0 = arg0;
1688     // Rule at src/isa/x64/inst.isle line 1400.
1689     let expr0_0 = SseOpcode::Pmovsxdq;
1690     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1691     return Some(expr1_0);
1692 }
1693 
1694 // Generated as internal constructor for term x64_pmovzxdq.
1695 pub fn constructor_x64_pmovzxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1696     let pattern0_0 = arg0;
1697     // Rule at src/isa/x64/inst.isle line 1404.
1698     let expr0_0 = SseOpcode::Pmovzxdq;
1699     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1700     return Some(expr1_0);
1701 }
1702 
1703 // Generated as internal constructor for term x64_xmm_load_const.
1704 pub fn constructor_x64_xmm_load_const<C: Context>(
1705     ctx: &mut C,
1706     arg0: Type,
1707     arg1: VCodeConstant,
1708 ) -> Option<Xmm> {
1709     let pattern0_0 = arg0;
1710     let pattern1_0 = arg1;
1711     // Rule at src/isa/x64/inst.isle line 1409.
1712     let expr0_0 = C::temp_writable_xmm(ctx);
1713     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
1714     let expr2_0 = MInst::XmmLoadConst {
1715         src: pattern1_0,
1716         dst: expr1_0,
1717         ty: pattern0_0,
1718     };
1719     let expr3_0 = C::emit(ctx, &expr2_0);
1720     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1721     return Some(expr4_0);
1722 }
1723 
1724 // Generated as internal constructor for term alu_rmi_r.
1725 pub fn constructor_alu_rmi_r<C: Context>(
1726     ctx: &mut C,
1727     arg0: Type,
1728     arg1: &AluRmiROpcode,
1729     arg2: Gpr,
1730     arg3: &GprMemImm,
1731 ) -> Option<Gpr> {
1732     let pattern0_0 = arg0;
1733     let pattern1_0 = arg1;
1734     let pattern2_0 = arg2;
1735     let pattern3_0 = arg3;
1736     // Rule at src/isa/x64/inst.isle line 1422.
1737     let expr0_0 = C::temp_writable_gpr(ctx);
1738     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1739     let expr2_0 = MInst::AluRmiR {
1740         size: expr1_0,
1741         op: pattern1_0.clone(),
1742         src1: pattern2_0,
1743         src2: pattern3_0.clone(),
1744         dst: expr0_0,
1745     };
1746     let expr3_0 = C::emit(ctx, &expr2_0);
1747     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1748     return Some(expr4_0);
1749 }
1750 
1751 // Generated as internal constructor for term x64_add.
1752 pub fn constructor_x64_add<C: Context>(
1753     ctx: &mut C,
1754     arg0: Type,
1755     arg1: Gpr,
1756     arg2: &GprMemImm,
1757 ) -> Option<Gpr> {
1758     let pattern0_0 = arg0;
1759     let pattern1_0 = arg1;
1760     let pattern2_0 = arg2;
1761     // Rule at src/isa/x64/inst.isle line 1430.
1762     let expr0_0 = AluRmiROpcode::Add;
1763     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1764     return Some(expr1_0);
1765 }
1766 
1767 // Generated as internal constructor for term x64_add_with_flags_paired.
1768 pub fn constructor_x64_add_with_flags_paired<C: Context>(
1769     ctx: &mut C,
1770     arg0: Type,
1771     arg1: Gpr,
1772     arg2: &GprMemImm,
1773 ) -> Option<ProducesFlags> {
1774     let pattern0_0 = arg0;
1775     let pattern1_0 = arg1;
1776     let pattern2_0 = arg2;
1777     // Rule at src/isa/x64/inst.isle line 1438.
1778     let expr0_0 = C::temp_writable_gpr(ctx);
1779     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1780     let expr2_0 = AluRmiROpcode::Add;
1781     let expr3_0 = MInst::AluRmiR {
1782         size: expr1_0,
1783         op: expr2_0,
1784         src1: pattern1_0,
1785         src2: pattern2_0.clone(),
1786         dst: expr0_0,
1787     };
1788     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1789     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
1790         inst: expr3_0,
1791         result: expr4_0,
1792     };
1793     return Some(expr5_0);
1794 }
1795 
1796 // Generated as internal constructor for term x64_adc_paired.
1797 pub fn constructor_x64_adc_paired<C: Context>(
1798     ctx: &mut C,
1799     arg0: Type,
1800     arg1: Gpr,
1801     arg2: &GprMemImm,
1802 ) -> Option<ConsumesFlags> {
1803     let pattern0_0 = arg0;
1804     let pattern1_0 = arg1;
1805     let pattern2_0 = arg2;
1806     // Rule at src/isa/x64/inst.isle line 1450.
1807     let expr0_0 = C::temp_writable_gpr(ctx);
1808     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1809     let expr2_0 = AluRmiROpcode::Adc;
1810     let expr3_0 = MInst::AluRmiR {
1811         size: expr1_0,
1812         op: expr2_0,
1813         src1: pattern1_0,
1814         src2: pattern2_0.clone(),
1815         dst: expr0_0,
1816     };
1817     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1818     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
1819         inst: expr3_0,
1820         result: expr4_0,
1821     };
1822     return Some(expr5_0);
1823 }
1824 
1825 // Generated as internal constructor for term x64_sub.
1826 pub fn constructor_x64_sub<C: Context>(
1827     ctx: &mut C,
1828     arg0: Type,
1829     arg1: Gpr,
1830     arg2: &GprMemImm,
1831 ) -> Option<Gpr> {
1832     let pattern0_0 = arg0;
1833     let pattern1_0 = arg1;
1834     let pattern2_0 = arg2;
1835     // Rule at src/isa/x64/inst.isle line 1462.
1836     let expr0_0 = AluRmiROpcode::Sub;
1837     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1838     return Some(expr1_0);
1839 }
1840 
1841 // Generated as internal constructor for term x64_sub_with_flags_paired.
1842 pub fn constructor_x64_sub_with_flags_paired<C: Context>(
1843     ctx: &mut C,
1844     arg0: Type,
1845     arg1: Gpr,
1846     arg2: &GprMemImm,
1847 ) -> Option<ProducesFlags> {
1848     let pattern0_0 = arg0;
1849     let pattern1_0 = arg1;
1850     let pattern2_0 = arg2;
1851     // Rule at src/isa/x64/inst.isle line 1470.
1852     let expr0_0 = C::temp_writable_gpr(ctx);
1853     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1854     let expr2_0 = AluRmiROpcode::Sub;
1855     let expr3_0 = MInst::AluRmiR {
1856         size: expr1_0,
1857         op: expr2_0,
1858         src1: pattern1_0,
1859         src2: pattern2_0.clone(),
1860         dst: expr0_0,
1861     };
1862     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1863     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
1864         inst: expr3_0,
1865         result: expr4_0,
1866     };
1867     return Some(expr5_0);
1868 }
1869 
1870 // Generated as internal constructor for term x64_sbb_paired.
1871 pub fn constructor_x64_sbb_paired<C: Context>(
1872     ctx: &mut C,
1873     arg0: Type,
1874     arg1: Gpr,
1875     arg2: &GprMemImm,
1876 ) -> Option<ConsumesFlags> {
1877     let pattern0_0 = arg0;
1878     let pattern1_0 = arg1;
1879     let pattern2_0 = arg2;
1880     // Rule at src/isa/x64/inst.isle line 1482.
1881     let expr0_0 = C::temp_writable_gpr(ctx);
1882     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1883     let expr2_0 = AluRmiROpcode::Sbb;
1884     let expr3_0 = MInst::AluRmiR {
1885         size: expr1_0,
1886         op: expr2_0,
1887         src1: pattern1_0,
1888         src2: pattern2_0.clone(),
1889         dst: expr0_0,
1890     };
1891     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1892     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
1893         inst: expr3_0,
1894         result: expr4_0,
1895     };
1896     return Some(expr5_0);
1897 }
1898 
1899 // Generated as internal constructor for term x64_mul.
1900 pub fn constructor_x64_mul<C: Context>(
1901     ctx: &mut C,
1902     arg0: Type,
1903     arg1: Gpr,
1904     arg2: &GprMemImm,
1905 ) -> Option<Gpr> {
1906     let pattern0_0 = arg0;
1907     let pattern1_0 = arg1;
1908     let pattern2_0 = arg2;
1909     // Rule at src/isa/x64/inst.isle line 1494.
1910     let expr0_0 = AluRmiROpcode::Mul;
1911     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1912     return Some(expr1_0);
1913 }
1914 
1915 // Generated as internal constructor for term x64_and.
1916 pub fn constructor_x64_and<C: Context>(
1917     ctx: &mut C,
1918     arg0: Type,
1919     arg1: Gpr,
1920     arg2: &GprMemImm,
1921 ) -> Option<Gpr> {
1922     let pattern0_0 = arg0;
1923     let pattern1_0 = arg1;
1924     let pattern2_0 = arg2;
1925     // Rule at src/isa/x64/inst.isle line 1502.
1926     let expr0_0 = AluRmiROpcode::And;
1927     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1928     return Some(expr1_0);
1929 }
1930 
1931 // Generated as internal constructor for term x64_and_with_flags_paired.
1932 pub fn constructor_x64_and_with_flags_paired<C: Context>(
1933     ctx: &mut C,
1934     arg0: Type,
1935     arg1: Gpr,
1936     arg2: &GprMemImm,
1937 ) -> Option<ProducesFlags> {
1938     let pattern0_0 = arg0;
1939     let pattern1_0 = arg1;
1940     let pattern2_0 = arg2;
1941     // Rule at src/isa/x64/inst.isle line 1509.
1942     let expr0_0 = C::temp_writable_gpr(ctx);
1943     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1944     let expr2_0 = AluRmiROpcode::And;
1945     let expr3_0 = MInst::AluRmiR {
1946         size: expr1_0,
1947         op: expr2_0,
1948         src1: pattern1_0,
1949         src2: pattern2_0.clone(),
1950         dst: expr0_0,
1951     };
1952     let expr4_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr3_0 };
1953     return Some(expr4_0);
1954 }
1955 
1956 // Generated as internal constructor for term x64_or.
1957 pub fn constructor_x64_or<C: Context>(
1958     ctx: &mut C,
1959     arg0: Type,
1960     arg1: Gpr,
1961     arg2: &GprMemImm,
1962 ) -> Option<Gpr> {
1963     let pattern0_0 = arg0;
1964     let pattern1_0 = arg1;
1965     let pattern2_0 = arg2;
1966     // Rule at src/isa/x64/inst.isle line 1520.
1967     let expr0_0 = AluRmiROpcode::Or;
1968     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1969     return Some(expr1_0);
1970 }
1971 
1972 // Generated as internal constructor for term x64_xor.
1973 pub fn constructor_x64_xor<C: Context>(
1974     ctx: &mut C,
1975     arg0: Type,
1976     arg1: Gpr,
1977     arg2: &GprMemImm,
1978 ) -> Option<Gpr> {
1979     let pattern0_0 = arg0;
1980     let pattern1_0 = arg1;
1981     let pattern2_0 = arg2;
1982     // Rule at src/isa/x64/inst.isle line 1528.
1983     let expr0_0 = AluRmiROpcode::Xor;
1984     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1985     return Some(expr1_0);
1986 }
1987 
1988 // Generated as internal constructor for term imm.
1989 pub fn constructor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: u64) -> Option<Reg> {
1990     let pattern0_0 = arg0;
1991     if pattern0_0 == I64 {
1992         let pattern2_0 = arg1;
1993         if let Some(pattern3_0) = C::nonzero_u64_fits_in_u32(ctx, pattern2_0) {
1994             // Rule at src/isa/x64/inst.isle line 1568.
1995             let expr0_0 = C::temp_writable_gpr(ctx);
1996             let expr1_0 = OperandSize::Size32;
1997             let expr2_0 = MInst::Imm {
1998                 dst_size: expr1_0,
1999                 simm64: pattern3_0,
2000                 dst: expr0_0,
2001             };
2002             let expr3_0 = C::emit(ctx, &expr2_0);
2003             let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2004             return Some(expr4_0);
2005         }
2006     }
2007     if pattern0_0 == F32 {
2008         let pattern2_0 = arg1;
2009         if pattern2_0 == 0 {
2010             // Rule at src/isa/x64/inst.isle line 1597.
2011             let expr0_0 = C::temp_writable_xmm(ctx);
2012             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2013             let expr2_0 = SseOpcode::Xorps;
2014             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2015             let expr4_0 = MInst::XmmRmR {
2016                 op: expr2_0,
2017                 src1: expr1_0,
2018                 src2: expr3_0,
2019                 dst: expr0_0,
2020             };
2021             let expr5_0 = C::emit(ctx, &expr4_0);
2022             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2023             return Some(expr6_0);
2024         }
2025         // Rule at src/isa/x64/inst.isle line 1545.
2026         let expr0_0 = SseOpcode::Movd;
2027         let expr1_0: Type = I32;
2028         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2029         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2030         let expr4_0 = OperandSize::Size32;
2031         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2032         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2033         return Some(expr6_0);
2034     }
2035     if pattern0_0 == F64 {
2036         let pattern2_0 = arg1;
2037         if pattern2_0 == 0 {
2038             // Rule at src/isa/x64/inst.isle line 1609.
2039             let expr0_0 = C::temp_writable_xmm(ctx);
2040             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2041             let expr2_0 = SseOpcode::Xorpd;
2042             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2043             let expr4_0 = MInst::XmmRmR {
2044                 op: expr2_0,
2045                 src1: expr1_0,
2046                 src2: expr3_0,
2047                 dst: expr0_0,
2048             };
2049             let expr5_0 = C::emit(ctx, &expr4_0);
2050             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2051             return Some(expr6_0);
2052         }
2053         // Rule at src/isa/x64/inst.isle line 1551.
2054         let expr0_0 = SseOpcode::Movq;
2055         let expr1_0: Type = I64;
2056         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2057         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2058         let expr4_0 = OperandSize::Size64;
2059         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2060         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2061         return Some(expr6_0);
2062     }
2063     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
2064         let pattern2_0 = arg1;
2065         if pattern2_0 == 0 {
2066             // Rule at src/isa/x64/inst.isle line 1587.
2067             let expr0_0 = C::temp_writable_xmm(ctx);
2068             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2069             let expr2_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
2070             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2071             let expr4_0 = MInst::XmmRmR {
2072                 op: expr2_0,
2073                 src1: expr1_0,
2074                 src2: expr3_0,
2075                 dst: expr0_0,
2076             };
2077             let expr5_0 = C::emit(ctx, &expr4_0);
2078             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2079             return Some(expr6_0);
2080         }
2081     }
2082     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
2083         let pattern2_0 = arg1;
2084         if pattern2_0 == 0 {
2085             // Rule at src/isa/x64/inst.isle line 1574.
2086             let expr0_0 = C::temp_writable_gpr(ctx);
2087             let expr1_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2088             let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2089             let expr3_0 = AluRmiROpcode::Xor;
2090             let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
2091             let expr5_0 = MInst::AluRmiR {
2092                 size: expr2_0,
2093                 op: expr3_0,
2094                 src1: expr1_0,
2095                 src2: expr4_0,
2096                 dst: expr0_0,
2097             };
2098             let expr6_0 = C::emit(ctx, &expr5_0);
2099             let expr7_0 = C::gpr_to_reg(ctx, expr1_0);
2100             return Some(expr7_0);
2101         }
2102         // Rule at src/isa/x64/inst.isle line 1538.
2103         let expr0_0 = C::temp_writable_gpr(ctx);
2104         let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2105         let expr2_0 = MInst::Imm {
2106             dst_size: expr1_0,
2107             simm64: pattern2_0,
2108             dst: expr0_0,
2109         };
2110         let expr3_0 = C::emit(ctx, &expr2_0);
2111         let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2112         return Some(expr4_0);
2113     }
2114     return None;
2115 }
2116 
2117 // Generated as internal constructor for term imm_i64.
2118 pub fn constructor_imm_i64<C: Context>(ctx: &mut C, arg0: Type, arg1: i64) -> Option<Reg> {
2119     let pattern0_0 = arg0;
2120     let pattern1_0 = arg1;
2121     // Rule at src/isa/x64/inst.isle line 1560.
2122     let expr0_0 = C::i64_as_u64(ctx, pattern1_0);
2123     let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
2124     return Some(expr1_0);
2125 }
2126 
2127 // Generated as internal constructor for term shift_r.
2128 pub fn constructor_shift_r<C: Context>(
2129     ctx: &mut C,
2130     arg0: Type,
2131     arg1: &ShiftKind,
2132     arg2: Gpr,
2133     arg3: &Imm8Gpr,
2134 ) -> Option<Gpr> {
2135     let pattern0_0 = arg0;
2136     let pattern1_0 = arg1;
2137     let pattern2_0 = arg2;
2138     let pattern3_0 = arg3;
2139     // Rule at src/isa/x64/inst.isle line 1622.
2140     let expr0_0 = C::temp_writable_gpr(ctx);
2141     let expr1_0 = C::raw_operand_size_of_type(ctx, pattern0_0);
2142     let expr2_0 = MInst::ShiftR {
2143         size: expr1_0,
2144         kind: pattern1_0.clone(),
2145         src: pattern2_0,
2146         num_bits: pattern3_0.clone(),
2147         dst: expr0_0,
2148     };
2149     let expr3_0 = C::emit(ctx, &expr2_0);
2150     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2151     return Some(expr4_0);
2152 }
2153 
2154 // Generated as internal constructor for term x64_rotl.
2155 pub fn constructor_x64_rotl<C: Context>(
2156     ctx: &mut C,
2157     arg0: Type,
2158     arg1: Gpr,
2159     arg2: &Imm8Gpr,
2160 ) -> Option<Gpr> {
2161     let pattern0_0 = arg0;
2162     let pattern1_0 = arg1;
2163     let pattern2_0 = arg2;
2164     // Rule at src/isa/x64/inst.isle line 1632.
2165     let expr0_0 = ShiftKind::RotateLeft;
2166     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2167     return Some(expr1_0);
2168 }
2169 
2170 // Generated as internal constructor for term x64_rotr.
2171 pub fn constructor_x64_rotr<C: Context>(
2172     ctx: &mut C,
2173     arg0: Type,
2174     arg1: Gpr,
2175     arg2: &Imm8Gpr,
2176 ) -> Option<Gpr> {
2177     let pattern0_0 = arg0;
2178     let pattern1_0 = arg1;
2179     let pattern2_0 = arg2;
2180     // Rule at src/isa/x64/inst.isle line 1637.
2181     let expr0_0 = ShiftKind::RotateRight;
2182     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2183     return Some(expr1_0);
2184 }
2185 
2186 // Generated as internal constructor for term x64_shl.
2187 pub fn constructor_x64_shl<C: Context>(
2188     ctx: &mut C,
2189     arg0: Type,
2190     arg1: Gpr,
2191     arg2: &Imm8Gpr,
2192 ) -> Option<Gpr> {
2193     let pattern0_0 = arg0;
2194     let pattern1_0 = arg1;
2195     let pattern2_0 = arg2;
2196     // Rule at src/isa/x64/inst.isle line 1642.
2197     let expr0_0 = ShiftKind::ShiftLeft;
2198     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2199     return Some(expr1_0);
2200 }
2201 
2202 // Generated as internal constructor for term x64_shr.
2203 pub fn constructor_x64_shr<C: Context>(
2204     ctx: &mut C,
2205     arg0: Type,
2206     arg1: Gpr,
2207     arg2: &Imm8Gpr,
2208 ) -> Option<Gpr> {
2209     let pattern0_0 = arg0;
2210     let pattern1_0 = arg1;
2211     let pattern2_0 = arg2;
2212     // Rule at src/isa/x64/inst.isle line 1647.
2213     let expr0_0 = ShiftKind::ShiftRightLogical;
2214     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2215     return Some(expr1_0);
2216 }
2217 
2218 // Generated as internal constructor for term x64_sar.
2219 pub fn constructor_x64_sar<C: Context>(
2220     ctx: &mut C,
2221     arg0: Type,
2222     arg1: Gpr,
2223     arg2: &Imm8Gpr,
2224 ) -> Option<Gpr> {
2225     let pattern0_0 = arg0;
2226     let pattern1_0 = arg1;
2227     let pattern2_0 = arg2;
2228     // Rule at src/isa/x64/inst.isle line 1652.
2229     let expr0_0 = ShiftKind::ShiftRightArithmetic;
2230     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2231     return Some(expr1_0);
2232 }
2233 
2234 // Generated as internal constructor for term cmp_rmi_r.
2235 pub fn constructor_cmp_rmi_r<C: Context>(
2236     ctx: &mut C,
2237     arg0: &OperandSize,
2238     arg1: &CmpOpcode,
2239     arg2: &GprMemImm,
2240     arg3: Gpr,
2241 ) -> Option<ProducesFlags> {
2242     let pattern0_0 = arg0;
2243     let pattern1_0 = arg1;
2244     let pattern2_0 = arg2;
2245     let pattern3_0 = arg3;
2246     // Rule at src/isa/x64/inst.isle line 1657.
2247     let expr0_0 = MInst::CmpRmiR {
2248         size: pattern0_0.clone(),
2249         opcode: pattern1_0.clone(),
2250         src: pattern2_0.clone(),
2251         dst: pattern3_0,
2252     };
2253     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2254     return Some(expr1_0);
2255 }
2256 
2257 // Generated as internal constructor for term x64_cmp.
2258 pub fn constructor_x64_cmp<C: Context>(
2259     ctx: &mut C,
2260     arg0: &OperandSize,
2261     arg1: &GprMemImm,
2262     arg2: Gpr,
2263 ) -> Option<ProducesFlags> {
2264     let pattern0_0 = arg0;
2265     let pattern1_0 = arg1;
2266     let pattern2_0 = arg2;
2267     // Rule at src/isa/x64/inst.isle line 1666.
2268     let expr0_0 = CmpOpcode::Cmp;
2269     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2270     return Some(expr1_0);
2271 }
2272 
2273 // Generated as internal constructor for term x64_cmp_imm.
2274 pub fn constructor_x64_cmp_imm<C: Context>(
2275     ctx: &mut C,
2276     arg0: &OperandSize,
2277     arg1: u32,
2278     arg2: Gpr,
2279 ) -> Option<ProducesFlags> {
2280     let pattern0_0 = arg0;
2281     let pattern1_0 = arg1;
2282     let pattern2_0 = arg2;
2283     // Rule at src/isa/x64/inst.isle line 1671.
2284     let expr0_0 = CmpOpcode::Cmp;
2285     let expr1_0 = RegMemImm::Imm { simm32: pattern1_0 };
2286     let expr2_0 = C::gpr_mem_imm_new(ctx, &expr1_0);
2287     let expr3_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, &expr2_0, pattern2_0)?;
2288     return Some(expr3_0);
2289 }
2290 
2291 // Generated as internal constructor for term xmm_cmp_rm_r.
2292 pub fn constructor_xmm_cmp_rm_r<C: Context>(
2293     ctx: &mut C,
2294     arg0: &SseOpcode,
2295     arg1: &XmmMem,
2296     arg2: Xmm,
2297 ) -> Option<ProducesFlags> {
2298     let pattern0_0 = arg0;
2299     let pattern1_0 = arg1;
2300     let pattern2_0 = arg2;
2301     // Rule at src/isa/x64/inst.isle line 1676.
2302     let expr0_0 = MInst::XmmCmpRmR {
2303         op: pattern0_0.clone(),
2304         src: pattern1_0.clone(),
2305         dst: pattern2_0,
2306     };
2307     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2308     return Some(expr1_0);
2309 }
2310 
2311 // Generated as internal constructor for term x64_ucomis.
2312 pub fn constructor_x64_ucomis<C: Context>(
2313     ctx: &mut C,
2314     arg0: Value,
2315     arg1: Value,
2316 ) -> Option<ProducesFlags> {
2317     let pattern0_0 = arg0;
2318     let pattern1_0 = C::value_type(ctx, pattern0_0);
2319     if pattern1_0 == F32 {
2320         let pattern3_0 = arg1;
2321         // Rule at src/isa/x64/inst.isle line 1682.
2322         let expr0_0 = SseOpcode::Ucomiss;
2323         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2324         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2325         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2326         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2327         return Some(expr4_0);
2328     }
2329     if pattern1_0 == F64 {
2330         let pattern3_0 = arg1;
2331         // Rule at src/isa/x64/inst.isle line 1686.
2332         let expr0_0 = SseOpcode::Ucomisd;
2333         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2334         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2335         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2336         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2337         return Some(expr4_0);
2338     }
2339     return None;
2340 }
2341 
2342 // Generated as internal constructor for term x64_test.
2343 pub fn constructor_x64_test<C: Context>(
2344     ctx: &mut C,
2345     arg0: &OperandSize,
2346     arg1: &GprMemImm,
2347     arg2: Gpr,
2348 ) -> Option<ProducesFlags> {
2349     let pattern0_0 = arg0;
2350     let pattern1_0 = arg1;
2351     let pattern2_0 = arg2;
2352     // Rule at src/isa/x64/inst.isle line 1691.
2353     let expr0_0 = CmpOpcode::Test;
2354     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2355     return Some(expr1_0);
2356 }
2357 
2358 // Generated as internal constructor for term cmove.
2359 pub fn constructor_cmove<C: Context>(
2360     ctx: &mut C,
2361     arg0: Type,
2362     arg1: &CC,
2363     arg2: &GprMem,
2364     arg3: Gpr,
2365 ) -> Option<ConsumesFlags> {
2366     let pattern0_0 = arg0;
2367     let pattern1_0 = arg1;
2368     let pattern2_0 = arg2;
2369     let pattern3_0 = arg3;
2370     // Rule at src/isa/x64/inst.isle line 1698.
2371     let expr0_0 = C::temp_writable_gpr(ctx);
2372     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2373     let expr2_0 = MInst::Cmove {
2374         size: expr1_0,
2375         cc: pattern1_0.clone(),
2376         consequent: pattern2_0.clone(),
2377         alternative: pattern3_0,
2378         dst: expr0_0,
2379     };
2380     let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2381     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2382         inst: expr2_0,
2383         result: expr3_0,
2384     };
2385     return Some(expr4_0);
2386 }
2387 
2388 // Generated as internal constructor for term cmove_xmm.
2389 pub fn constructor_cmove_xmm<C: Context>(
2390     ctx: &mut C,
2391     arg0: Type,
2392     arg1: &CC,
2393     arg2: &XmmMem,
2394     arg3: Xmm,
2395 ) -> Option<ConsumesFlags> {
2396     let pattern0_0 = arg0;
2397     let pattern1_0 = arg1;
2398     let pattern2_0 = arg2;
2399     let pattern3_0 = arg3;
2400     // Rule at src/isa/x64/inst.isle line 1706.
2401     let expr0_0 = C::temp_writable_xmm(ctx);
2402     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2403     let expr2_0 = MInst::XmmCmove {
2404         size: expr1_0,
2405         cc: pattern1_0.clone(),
2406         consequent: pattern2_0.clone(),
2407         alternative: pattern3_0,
2408         dst: expr0_0,
2409     };
2410     let expr3_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
2411     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2412         inst: expr2_0,
2413         result: expr3_0,
2414     };
2415     return Some(expr4_0);
2416 }
2417 
2418 // Generated as internal constructor for term cmove_from_values.
2419 pub fn constructor_cmove_from_values<C: Context>(
2420     ctx: &mut C,
2421     arg0: Type,
2422     arg1: &CC,
2423     arg2: Value,
2424     arg3: Value,
2425 ) -> Option<ConsumesFlags> {
2426     let pattern0_0 = arg0;
2427     if pattern0_0 == I128 {
2428         let pattern2_0 = arg1;
2429         let pattern3_0 = arg2;
2430         let pattern4_0 = arg3;
2431         // Rule at src/isa/x64/inst.isle line 1717.
2432         let expr0_0 = C::put_in_regs(ctx, pattern3_0);
2433         let expr1_0 = C::put_in_regs(ctx, pattern4_0);
2434         let expr2_0 = C::temp_writable_gpr(ctx);
2435         let expr3_0 = C::temp_writable_gpr(ctx);
2436         let expr4_0 = OperandSize::Size64;
2437         let expr5_0: usize = 0;
2438         let expr6_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr5_0)?;
2439         let expr7_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
2440         let expr8_0: usize = 0;
2441         let expr9_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr8_0)?;
2442         let expr10_0 = MInst::Cmove {
2443             size: expr4_0,
2444             cc: pattern2_0.clone(),
2445             consequent: expr7_0,
2446             alternative: expr9_0,
2447             dst: expr2_0,
2448         };
2449         let expr11_0: usize = 1;
2450         let expr12_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr11_0)?;
2451         let expr13_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
2452         let expr14_0: usize = 1;
2453         let expr15_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr14_0)?;
2454         let expr16_0 = MInst::Cmove {
2455             size: expr4_0,
2456             cc: pattern2_0.clone(),
2457             consequent: expr13_0,
2458             alternative: expr15_0,
2459             dst: expr3_0,
2460         };
2461         let expr17_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
2462         let expr18_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
2463         let expr19_0 = C::value_regs(ctx, expr17_0, expr18_0);
2464         let expr20_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2465             inst1: expr10_0,
2466             inst2: expr16_0,
2467             result: expr19_0,
2468         };
2469         return Some(expr20_0);
2470     }
2471     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
2472         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2473             let pattern3_0 = arg1;
2474             let pattern4_0 = arg2;
2475             let pattern5_0 = arg3;
2476             // Rule at src/isa/x64/inst.isle line 1741.
2477             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
2478             let expr1_0 = constructor_put_in_xmm(ctx, pattern5_0)?;
2479             let expr2_0 = constructor_cmove_xmm(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2480             return Some(expr2_0);
2481         }
2482     }
2483     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
2484         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2485             let pattern3_0 = arg1;
2486             let pattern4_0 = arg2;
2487             let pattern5_0 = arg3;
2488             // Rule at src/isa/x64/inst.isle line 1738.
2489             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern4_0)?;
2490             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_0)?;
2491             let expr2_0 = constructor_cmove(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2492             return Some(expr2_0);
2493         }
2494     }
2495     return None;
2496 }
2497 
2498 // Generated as internal constructor for term cmove_or.
2499 pub fn constructor_cmove_or<C: Context>(
2500     ctx: &mut C,
2501     arg0: Type,
2502     arg1: &CC,
2503     arg2: &CC,
2504     arg3: &GprMem,
2505     arg4: Gpr,
2506 ) -> Option<ConsumesFlags> {
2507     let pattern0_0 = arg0;
2508     let pattern1_0 = arg1;
2509     let pattern2_0 = arg2;
2510     let pattern3_0 = arg3;
2511     let pattern4_0 = arg4;
2512     // Rule at src/isa/x64/inst.isle line 1748.
2513     let expr0_0 = C::temp_writable_gpr(ctx);
2514     let expr1_0 = C::temp_writable_gpr(ctx);
2515     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2516     let expr3_0 = MInst::Cmove {
2517         size: expr2_0,
2518         cc: pattern1_0.clone(),
2519         consequent: pattern3_0.clone(),
2520         alternative: pattern4_0,
2521         dst: expr1_0,
2522     };
2523     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
2524     let expr5_0 = MInst::Cmove {
2525         size: expr2_0,
2526         cc: pattern2_0.clone(),
2527         consequent: pattern3_0.clone(),
2528         alternative: expr4_0,
2529         dst: expr0_0,
2530     };
2531     let expr6_0 = constructor_writable_gpr_to_value_regs(ctx, expr0_0)?;
2532     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2533         inst1: expr3_0,
2534         inst2: expr5_0,
2535         result: expr6_0,
2536     };
2537     return Some(expr7_0);
2538 }
2539 
2540 // Generated as internal constructor for term cmove_or_xmm.
2541 pub fn constructor_cmove_or_xmm<C: Context>(
2542     ctx: &mut C,
2543     arg0: Type,
2544     arg1: &CC,
2545     arg2: &CC,
2546     arg3: &XmmMem,
2547     arg4: Xmm,
2548 ) -> Option<ConsumesFlags> {
2549     let pattern0_0 = arg0;
2550     let pattern1_0 = arg1;
2551     let pattern2_0 = arg2;
2552     let pattern3_0 = arg3;
2553     let pattern4_0 = arg4;
2554     // Rule at src/isa/x64/inst.isle line 1760.
2555     let expr0_0 = C::temp_writable_xmm(ctx);
2556     let expr1_0 = C::temp_writable_xmm(ctx);
2557     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2558     let expr3_0 = MInst::XmmCmove {
2559         size: expr2_0,
2560         cc: pattern1_0.clone(),
2561         consequent: pattern3_0.clone(),
2562         alternative: pattern4_0,
2563         dst: expr1_0,
2564     };
2565     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr1_0);
2566     let expr5_0 = MInst::XmmCmove {
2567         size: expr2_0,
2568         cc: pattern2_0.clone(),
2569         consequent: pattern3_0.clone(),
2570         alternative: expr4_0,
2571         dst: expr0_0,
2572     };
2573     let expr6_0 = constructor_writable_xmm_to_value_regs(ctx, expr0_0)?;
2574     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2575         inst1: expr3_0,
2576         inst2: expr5_0,
2577         result: expr6_0,
2578     };
2579     return Some(expr7_0);
2580 }
2581 
2582 // Generated as internal constructor for term cmove_or_from_values.
2583 pub fn constructor_cmove_or_from_values<C: Context>(
2584     ctx: &mut C,
2585     arg0: Type,
2586     arg1: &CC,
2587     arg2: &CC,
2588     arg3: Value,
2589     arg4: Value,
2590 ) -> Option<ConsumesFlags> {
2591     let pattern0_0 = arg0;
2592     if pattern0_0 == I128 {
2593         let pattern2_0 = arg1;
2594         let pattern3_0 = arg2;
2595         let pattern4_0 = arg3;
2596         let pattern5_0 = arg4;
2597         // Rule at src/isa/x64/inst.isle line 1775.
2598         let expr0_0 = C::put_in_regs(ctx, pattern4_0);
2599         let expr1_0 = C::put_in_regs(ctx, pattern5_0);
2600         let expr2_0 = C::temp_writable_gpr(ctx);
2601         let expr3_0 = C::temp_writable_gpr(ctx);
2602         let expr4_0 = C::temp_writable_gpr(ctx);
2603         let expr5_0 = C::temp_writable_gpr(ctx);
2604         let expr6_0 = OperandSize::Size64;
2605         let expr7_0: usize = 0;
2606         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr7_0)?;
2607         let expr9_0 = C::gpr_to_gpr_mem(ctx, expr8_0);
2608         let expr10_0: usize = 0;
2609         let expr11_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr10_0)?;
2610         let expr12_0 = MInst::Cmove {
2611             size: expr6_0,
2612             cc: pattern2_0.clone(),
2613             consequent: expr9_0,
2614             alternative: expr11_0,
2615             dst: expr4_0,
2616         };
2617         let expr13_0: usize = 0;
2618         let expr14_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr13_0)?;
2619         let expr15_0 = C::gpr_to_gpr_mem(ctx, expr14_0);
2620         let expr16_0 = C::writable_gpr_to_gpr(ctx, expr4_0);
2621         let expr17_0 = MInst::Cmove {
2622             size: expr6_0,
2623             cc: pattern3_0.clone(),
2624             consequent: expr15_0,
2625             alternative: expr16_0,
2626             dst: expr2_0,
2627         };
2628         let expr18_0: usize = 1;
2629         let expr19_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr18_0)?;
2630         let expr20_0 = C::gpr_to_gpr_mem(ctx, expr19_0);
2631         let expr21_0: usize = 1;
2632         let expr22_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr21_0)?;
2633         let expr23_0 = MInst::Cmove {
2634             size: expr6_0,
2635             cc: pattern2_0.clone(),
2636             consequent: expr20_0,
2637             alternative: expr22_0,
2638             dst: expr5_0,
2639         };
2640         let expr24_0: usize = 1;
2641         let expr25_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr24_0)?;
2642         let expr26_0 = C::gpr_to_gpr_mem(ctx, expr25_0);
2643         let expr27_0 = C::writable_gpr_to_gpr(ctx, expr5_0);
2644         let expr28_0 = MInst::Cmove {
2645             size: expr6_0,
2646             cc: pattern3_0.clone(),
2647             consequent: expr26_0,
2648             alternative: expr27_0,
2649             dst: expr3_0,
2650         };
2651         let expr29_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
2652         let expr30_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
2653         let expr31_0 = C::value_regs(ctx, expr29_0, expr30_0);
2654         let expr32_0 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
2655             inst1: expr12_0,
2656             inst2: expr17_0,
2657             inst3: expr23_0,
2658             inst4: expr28_0,
2659             result: expr31_0,
2660         };
2661         return Some(expr32_0);
2662     }
2663     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
2664         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2665             let pattern3_0 = arg1;
2666             let pattern4_0 = arg2;
2667             let pattern5_0 = arg3;
2668             let pattern6_0 = arg4;
2669             // Rule at src/isa/x64/inst.isle line 1797.
2670             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_0)?;
2671             let expr1_0 = constructor_put_in_xmm(ctx, pattern6_0)?;
2672             let expr2_0 = constructor_cmove_or_xmm(
2673                 ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0,
2674             )?;
2675             return Some(expr2_0);
2676         }
2677     }
2678     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
2679         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2680             let pattern3_0 = arg1;
2681             let pattern4_0 = arg2;
2682             let pattern5_0 = arg3;
2683             let pattern6_0 = arg4;
2684             // Rule at src/isa/x64/inst.isle line 1794.
2685             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern5_0)?;
2686             let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
2687             let expr2_0 =
2688                 constructor_cmove_or(ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0)?;
2689             return Some(expr2_0);
2690         }
2691     }
2692     return None;
2693 }
2694 
2695 // Generated as internal constructor for term x64_setcc.
2696 pub fn constructor_x64_setcc<C: Context>(ctx: &mut C, arg0: &CC) -> Option<ConsumesFlags> {
2697     let pattern0_0 = arg0;
2698     // Rule at src/isa/x64/inst.isle line 1802.
2699     let expr0_0 = C::temp_writable_gpr(ctx);
2700     let expr1_0 = MInst::Setcc {
2701         cc: pattern0_0.clone(),
2702         dst: expr0_0,
2703     };
2704     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2705     let expr3_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2706         inst: expr1_0,
2707         result: expr2_0,
2708     };
2709     return Some(expr3_0);
2710 }
2711 
2712 // Generated as internal constructor for term xmm_rm_r.
2713 pub fn constructor_xmm_rm_r<C: Context>(
2714     ctx: &mut C,
2715     arg0: Type,
2716     arg1: &SseOpcode,
2717     arg2: Xmm,
2718     arg3: &XmmMem,
2719 ) -> Option<Xmm> {
2720     let pattern0_0 = arg0;
2721     let pattern1_0 = arg1;
2722     let pattern2_0 = arg2;
2723     let pattern3_0 = arg3;
2724     // Rule at src/isa/x64/inst.isle line 1810.
2725     let expr0_0 = C::temp_writable_xmm(ctx);
2726     let expr1_0 = MInst::XmmRmR {
2727         op: pattern1_0.clone(),
2728         src1: pattern2_0,
2729         src2: pattern3_0.clone(),
2730         dst: expr0_0,
2731     };
2732     let expr2_0 = C::emit(ctx, &expr1_0);
2733     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2734     return Some(expr3_0);
2735 }
2736 
2737 // Generated as internal constructor for term x64_paddb.
2738 pub fn constructor_x64_paddb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2739     let pattern0_0 = arg0;
2740     let pattern1_0 = arg1;
2741     // Rule at src/isa/x64/inst.isle line 1817.
2742     let expr0_0: Type = I8X16;
2743     let expr1_0 = SseOpcode::Paddb;
2744     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2745     return Some(expr2_0);
2746 }
2747 
2748 // Generated as internal constructor for term x64_paddw.
2749 pub fn constructor_x64_paddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2750     let pattern0_0 = arg0;
2751     let pattern1_0 = arg1;
2752     // Rule at src/isa/x64/inst.isle line 1822.
2753     let expr0_0: Type = I16X8;
2754     let expr1_0 = SseOpcode::Paddw;
2755     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2756     return Some(expr2_0);
2757 }
2758 
2759 // Generated as internal constructor for term x64_paddd.
2760 pub fn constructor_x64_paddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2761     let pattern0_0 = arg0;
2762     let pattern1_0 = arg1;
2763     // Rule at src/isa/x64/inst.isle line 1827.
2764     let expr0_0: Type = I32X4;
2765     let expr1_0 = SseOpcode::Paddd;
2766     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2767     return Some(expr2_0);
2768 }
2769 
2770 // Generated as internal constructor for term x64_paddq.
2771 pub fn constructor_x64_paddq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2772     let pattern0_0 = arg0;
2773     let pattern1_0 = arg1;
2774     // Rule at src/isa/x64/inst.isle line 1832.
2775     let expr0_0: Type = I64X2;
2776     let expr1_0 = SseOpcode::Paddq;
2777     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2778     return Some(expr2_0);
2779 }
2780 
2781 // Generated as internal constructor for term x64_paddsb.
2782 pub fn constructor_x64_paddsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2783     let pattern0_0 = arg0;
2784     let pattern1_0 = arg1;
2785     // Rule at src/isa/x64/inst.isle line 1837.
2786     let expr0_0: Type = I8X16;
2787     let expr1_0 = SseOpcode::Paddsb;
2788     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2789     return Some(expr2_0);
2790 }
2791 
2792 // Generated as internal constructor for term x64_paddsw.
2793 pub fn constructor_x64_paddsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2794     let pattern0_0 = arg0;
2795     let pattern1_0 = arg1;
2796     // Rule at src/isa/x64/inst.isle line 1842.
2797     let expr0_0: Type = I16X8;
2798     let expr1_0 = SseOpcode::Paddsw;
2799     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2800     return Some(expr2_0);
2801 }
2802 
2803 // Generated as internal constructor for term x64_paddusb.
2804 pub fn constructor_x64_paddusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2805     let pattern0_0 = arg0;
2806     let pattern1_0 = arg1;
2807     // Rule at src/isa/x64/inst.isle line 1847.
2808     let expr0_0: Type = I8X16;
2809     let expr1_0 = SseOpcode::Paddusb;
2810     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2811     return Some(expr2_0);
2812 }
2813 
2814 // Generated as internal constructor for term x64_paddusw.
2815 pub fn constructor_x64_paddusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2816     let pattern0_0 = arg0;
2817     let pattern1_0 = arg1;
2818     // Rule at src/isa/x64/inst.isle line 1852.
2819     let expr0_0: Type = I16X8;
2820     let expr1_0 = SseOpcode::Paddusw;
2821     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2822     return Some(expr2_0);
2823 }
2824 
2825 // Generated as internal constructor for term x64_psubb.
2826 pub fn constructor_x64_psubb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2827     let pattern0_0 = arg0;
2828     let pattern1_0 = arg1;
2829     // Rule at src/isa/x64/inst.isle line 1857.
2830     let expr0_0: Type = I8X16;
2831     let expr1_0 = SseOpcode::Psubb;
2832     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2833     return Some(expr2_0);
2834 }
2835 
2836 // Generated as internal constructor for term x64_psubw.
2837 pub fn constructor_x64_psubw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2838     let pattern0_0 = arg0;
2839     let pattern1_0 = arg1;
2840     // Rule at src/isa/x64/inst.isle line 1862.
2841     let expr0_0: Type = I16X8;
2842     let expr1_0 = SseOpcode::Psubw;
2843     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2844     return Some(expr2_0);
2845 }
2846 
2847 // Generated as internal constructor for term x64_psubd.
2848 pub fn constructor_x64_psubd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2849     let pattern0_0 = arg0;
2850     let pattern1_0 = arg1;
2851     // Rule at src/isa/x64/inst.isle line 1867.
2852     let expr0_0: Type = I32X4;
2853     let expr1_0 = SseOpcode::Psubd;
2854     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2855     return Some(expr2_0);
2856 }
2857 
2858 // Generated as internal constructor for term x64_psubq.
2859 pub fn constructor_x64_psubq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2860     let pattern0_0 = arg0;
2861     let pattern1_0 = arg1;
2862     // Rule at src/isa/x64/inst.isle line 1872.
2863     let expr0_0: Type = I64X2;
2864     let expr1_0 = SseOpcode::Psubq;
2865     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2866     return Some(expr2_0);
2867 }
2868 
2869 // Generated as internal constructor for term x64_psubsb.
2870 pub fn constructor_x64_psubsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2871     let pattern0_0 = arg0;
2872     let pattern1_0 = arg1;
2873     // Rule at src/isa/x64/inst.isle line 1877.
2874     let expr0_0: Type = I8X16;
2875     let expr1_0 = SseOpcode::Psubsb;
2876     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2877     return Some(expr2_0);
2878 }
2879 
2880 // Generated as internal constructor for term x64_psubsw.
2881 pub fn constructor_x64_psubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2882     let pattern0_0 = arg0;
2883     let pattern1_0 = arg1;
2884     // Rule at src/isa/x64/inst.isle line 1882.
2885     let expr0_0: Type = I16X8;
2886     let expr1_0 = SseOpcode::Psubsw;
2887     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2888     return Some(expr2_0);
2889 }
2890 
2891 // Generated as internal constructor for term x64_psubusb.
2892 pub fn constructor_x64_psubusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2893     let pattern0_0 = arg0;
2894     let pattern1_0 = arg1;
2895     // Rule at src/isa/x64/inst.isle line 1887.
2896     let expr0_0: Type = I8X16;
2897     let expr1_0 = SseOpcode::Psubusb;
2898     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2899     return Some(expr2_0);
2900 }
2901 
2902 // Generated as internal constructor for term x64_psubusw.
2903 pub fn constructor_x64_psubusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2904     let pattern0_0 = arg0;
2905     let pattern1_0 = arg1;
2906     // Rule at src/isa/x64/inst.isle line 1892.
2907     let expr0_0: Type = I16X8;
2908     let expr1_0 = SseOpcode::Psubusw;
2909     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2910     return Some(expr2_0);
2911 }
2912 
2913 // Generated as internal constructor for term x64_pavgb.
2914 pub fn constructor_x64_pavgb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2915     let pattern0_0 = arg0;
2916     let pattern1_0 = arg1;
2917     // Rule at src/isa/x64/inst.isle line 1897.
2918     let expr0_0: Type = I8X16;
2919     let expr1_0 = SseOpcode::Pavgb;
2920     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2921     return Some(expr2_0);
2922 }
2923 
2924 // Generated as internal constructor for term x64_pavgw.
2925 pub fn constructor_x64_pavgw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2926     let pattern0_0 = arg0;
2927     let pattern1_0 = arg1;
2928     // Rule at src/isa/x64/inst.isle line 1902.
2929     let expr0_0: Type = I16X8;
2930     let expr1_0 = SseOpcode::Pavgw;
2931     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2932     return Some(expr2_0);
2933 }
2934 
2935 // Generated as internal constructor for term x64_pand.
2936 pub fn constructor_x64_pand<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2937     let pattern0_0 = arg0;
2938     let pattern1_0 = arg1;
2939     // Rule at src/isa/x64/inst.isle line 1907.
2940     let expr0_0: Type = F32X4;
2941     let expr1_0 = SseOpcode::Pand;
2942     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2943     return Some(expr2_0);
2944 }
2945 
2946 // Generated as internal constructor for term x64_andps.
2947 pub fn constructor_x64_andps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2948     let pattern0_0 = arg0;
2949     let pattern1_0 = arg1;
2950     // Rule at src/isa/x64/inst.isle line 1912.
2951     let expr0_0: Type = F32X4;
2952     let expr1_0 = SseOpcode::Andps;
2953     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2954     return Some(expr2_0);
2955 }
2956 
2957 // Generated as internal constructor for term x64_andpd.
2958 pub fn constructor_x64_andpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2959     let pattern0_0 = arg0;
2960     let pattern1_0 = arg1;
2961     // Rule at src/isa/x64/inst.isle line 1917.
2962     let expr0_0: Type = F64X2;
2963     let expr1_0 = SseOpcode::Andpd;
2964     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2965     return Some(expr2_0);
2966 }
2967 
2968 // Generated as internal constructor for term x64_por.
2969 pub fn constructor_x64_por<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2970     let pattern0_0 = arg0;
2971     let pattern1_0 = arg1;
2972     // Rule at src/isa/x64/inst.isle line 1922.
2973     let expr0_0: Type = F32X4;
2974     let expr1_0 = SseOpcode::Por;
2975     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2976     return Some(expr2_0);
2977 }
2978 
2979 // Generated as internal constructor for term x64_orps.
2980 pub fn constructor_x64_orps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2981     let pattern0_0 = arg0;
2982     let pattern1_0 = arg1;
2983     // Rule at src/isa/x64/inst.isle line 1927.
2984     let expr0_0: Type = F32X4;
2985     let expr1_0 = SseOpcode::Orps;
2986     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2987     return Some(expr2_0);
2988 }
2989 
2990 // Generated as internal constructor for term x64_orpd.
2991 pub fn constructor_x64_orpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2992     let pattern0_0 = arg0;
2993     let pattern1_0 = arg1;
2994     // Rule at src/isa/x64/inst.isle line 1932.
2995     let expr0_0: Type = F64X2;
2996     let expr1_0 = SseOpcode::Orpd;
2997     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2998     return Some(expr2_0);
2999 }
3000 
3001 // Generated as internal constructor for term x64_pxor.
3002 pub fn constructor_x64_pxor<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3003     let pattern0_0 = arg0;
3004     let pattern1_0 = arg1;
3005     // Rule at src/isa/x64/inst.isle line 1937.
3006     let expr0_0: Type = I8X16;
3007     let expr1_0 = SseOpcode::Pxor;
3008     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3009     return Some(expr2_0);
3010 }
3011 
3012 // Generated as internal constructor for term x64_xorps.
3013 pub fn constructor_x64_xorps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3014     let pattern0_0 = arg0;
3015     let pattern1_0 = arg1;
3016     // Rule at src/isa/x64/inst.isle line 1942.
3017     let expr0_0: Type = F32X4;
3018     let expr1_0 = SseOpcode::Xorps;
3019     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3020     return Some(expr2_0);
3021 }
3022 
3023 // Generated as internal constructor for term x64_xorpd.
3024 pub fn constructor_x64_xorpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3025     let pattern0_0 = arg0;
3026     let pattern1_0 = arg1;
3027     // Rule at src/isa/x64/inst.isle line 1947.
3028     let expr0_0: Type = F64X2;
3029     let expr1_0 = SseOpcode::Xorpd;
3030     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3031     return Some(expr2_0);
3032 }
3033 
3034 // Generated as internal constructor for term x64_pmullw.
3035 pub fn constructor_x64_pmullw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3036     let pattern0_0 = arg0;
3037     let pattern1_0 = arg1;
3038     // Rule at src/isa/x64/inst.isle line 1952.
3039     let expr0_0: Type = I16X8;
3040     let expr1_0 = SseOpcode::Pmullw;
3041     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3042     return Some(expr2_0);
3043 }
3044 
3045 // Generated as internal constructor for term x64_pmulld.
3046 pub fn constructor_x64_pmulld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3047     let pattern0_0 = arg0;
3048     let pattern1_0 = arg1;
3049     // Rule at src/isa/x64/inst.isle line 1957.
3050     let expr0_0: Type = I16X8;
3051     let expr1_0 = SseOpcode::Pmulld;
3052     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3053     return Some(expr2_0);
3054 }
3055 
3056 // Generated as internal constructor for term x64_pmulhw.
3057 pub fn constructor_x64_pmulhw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3058     let pattern0_0 = arg0;
3059     let pattern1_0 = arg1;
3060     // Rule at src/isa/x64/inst.isle line 1962.
3061     let expr0_0: Type = I16X8;
3062     let expr1_0 = SseOpcode::Pmulhw;
3063     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3064     return Some(expr2_0);
3065 }
3066 
3067 // Generated as internal constructor for term x64_pmulhuw.
3068 pub fn constructor_x64_pmulhuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3069     let pattern0_0 = arg0;
3070     let pattern1_0 = arg1;
3071     // Rule at src/isa/x64/inst.isle line 1967.
3072     let expr0_0: Type = I16X8;
3073     let expr1_0 = SseOpcode::Pmulhuw;
3074     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3075     return Some(expr2_0);
3076 }
3077 
3078 // Generated as internal constructor for term x64_pmuldq.
3079 pub fn constructor_x64_pmuldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3080     let pattern0_0 = arg0;
3081     let pattern1_0 = arg1;
3082     // Rule at src/isa/x64/inst.isle line 1972.
3083     let expr0_0: Type = I16X8;
3084     let expr1_0 = SseOpcode::Pmuldq;
3085     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3086     return Some(expr2_0);
3087 }
3088 
3089 // Generated as internal constructor for term x64_pmuludq.
3090 pub fn constructor_x64_pmuludq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3091     let pattern0_0 = arg0;
3092     let pattern1_0 = arg1;
3093     // Rule at src/isa/x64/inst.isle line 1977.
3094     let expr0_0: Type = I64X2;
3095     let expr1_0 = SseOpcode::Pmuludq;
3096     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3097     return Some(expr2_0);
3098 }
3099 
3100 // Generated as internal constructor for term x64_punpckhwd.
3101 pub fn constructor_x64_punpckhwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3102     let pattern0_0 = arg0;
3103     let pattern1_0 = arg1;
3104     // Rule at src/isa/x64/inst.isle line 1982.
3105     let expr0_0: Type = I16X8;
3106     let expr1_0 = SseOpcode::Punpckhwd;
3107     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3108     return Some(expr2_0);
3109 }
3110 
3111 // Generated as internal constructor for term x64_punpcklwd.
3112 pub fn constructor_x64_punpcklwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3113     let pattern0_0 = arg0;
3114     let pattern1_0 = arg1;
3115     // Rule at src/isa/x64/inst.isle line 1987.
3116     let expr0_0: Type = I16X8;
3117     let expr1_0 = SseOpcode::Punpcklwd;
3118     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3119     return Some(expr2_0);
3120 }
3121 
3122 // Generated as internal constructor for term x64_andnps.
3123 pub fn constructor_x64_andnps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3124     let pattern0_0 = arg0;
3125     let pattern1_0 = arg1;
3126     // Rule at src/isa/x64/inst.isle line 1992.
3127     let expr0_0: Type = F32X4;
3128     let expr1_0 = SseOpcode::Andnps;
3129     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3130     return Some(expr2_0);
3131 }
3132 
3133 // Generated as internal constructor for term x64_andnpd.
3134 pub fn constructor_x64_andnpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3135     let pattern0_0 = arg0;
3136     let pattern1_0 = arg1;
3137     // Rule at src/isa/x64/inst.isle line 1997.
3138     let expr0_0: Type = F64X2;
3139     let expr1_0 = SseOpcode::Andnpd;
3140     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3141     return Some(expr2_0);
3142 }
3143 
3144 // Generated as internal constructor for term x64_pandn.
3145 pub fn constructor_x64_pandn<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3146     let pattern0_0 = arg0;
3147     let pattern1_0 = arg1;
3148     // Rule at src/isa/x64/inst.isle line 2002.
3149     let expr0_0: Type = F64X2;
3150     let expr1_0 = SseOpcode::Pandn;
3151     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3152     return Some(expr2_0);
3153 }
3154 
3155 // Generated as internal constructor for term x64_addss.
3156 pub fn constructor_x64_addss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3157     let pattern0_0 = arg0;
3158     let pattern1_0 = arg1;
3159     // Rule at src/isa/x64/inst.isle line 2007.
3160     let expr0_0: Type = F32;
3161     let expr1_0 = SseOpcode::Addss;
3162     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3163     return Some(expr2_0);
3164 }
3165 
3166 // Generated as internal constructor for term x64_addsd.
3167 pub fn constructor_x64_addsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3168     let pattern0_0 = arg0;
3169     let pattern1_0 = arg1;
3170     // Rule at src/isa/x64/inst.isle line 2012.
3171     let expr0_0: Type = F64;
3172     let expr1_0 = SseOpcode::Addsd;
3173     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3174     return Some(expr2_0);
3175 }
3176 
3177 // Generated as internal constructor for term x64_addps.
3178 pub fn constructor_x64_addps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3179     let pattern0_0 = arg0;
3180     let pattern1_0 = arg1;
3181     // Rule at src/isa/x64/inst.isle line 2017.
3182     let expr0_0: Type = F32;
3183     let expr1_0 = SseOpcode::Addps;
3184     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3185     return Some(expr2_0);
3186 }
3187 
3188 // Generated as internal constructor for term x64_addpd.
3189 pub fn constructor_x64_addpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3190     let pattern0_0 = arg0;
3191     let pattern1_0 = arg1;
3192     // Rule at src/isa/x64/inst.isle line 2022.
3193     let expr0_0: Type = F32;
3194     let expr1_0 = SseOpcode::Addpd;
3195     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3196     return Some(expr2_0);
3197 }
3198 
3199 // Generated as internal constructor for term x64_subss.
3200 pub fn constructor_x64_subss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3201     let pattern0_0 = arg0;
3202     let pattern1_0 = arg1;
3203     // Rule at src/isa/x64/inst.isle line 2027.
3204     let expr0_0: Type = F32;
3205     let expr1_0 = SseOpcode::Subss;
3206     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3207     return Some(expr2_0);
3208 }
3209 
3210 // Generated as internal constructor for term x64_subsd.
3211 pub fn constructor_x64_subsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3212     let pattern0_0 = arg0;
3213     let pattern1_0 = arg1;
3214     // Rule at src/isa/x64/inst.isle line 2032.
3215     let expr0_0: Type = F64;
3216     let expr1_0 = SseOpcode::Subsd;
3217     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3218     return Some(expr2_0);
3219 }
3220 
3221 // Generated as internal constructor for term x64_subps.
3222 pub fn constructor_x64_subps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3223     let pattern0_0 = arg0;
3224     let pattern1_0 = arg1;
3225     // Rule at src/isa/x64/inst.isle line 2037.
3226     let expr0_0: Type = F32;
3227     let expr1_0 = SseOpcode::Subps;
3228     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3229     return Some(expr2_0);
3230 }
3231 
3232 // Generated as internal constructor for term x64_subpd.
3233 pub fn constructor_x64_subpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3234     let pattern0_0 = arg0;
3235     let pattern1_0 = arg1;
3236     // Rule at src/isa/x64/inst.isle line 2042.
3237     let expr0_0: Type = F32;
3238     let expr1_0 = SseOpcode::Subpd;
3239     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3240     return Some(expr2_0);
3241 }
3242 
3243 // Generated as internal constructor for term x64_mulss.
3244 pub fn constructor_x64_mulss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3245     let pattern0_0 = arg0;
3246     let pattern1_0 = arg1;
3247     // Rule at src/isa/x64/inst.isle line 2047.
3248     let expr0_0: Type = F32;
3249     let expr1_0 = SseOpcode::Mulss;
3250     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3251     return Some(expr2_0);
3252 }
3253 
3254 // Generated as internal constructor for term x64_mulsd.
3255 pub fn constructor_x64_mulsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3256     let pattern0_0 = arg0;
3257     let pattern1_0 = arg1;
3258     // Rule at src/isa/x64/inst.isle line 2052.
3259     let expr0_0: Type = F64;
3260     let expr1_0 = SseOpcode::Mulsd;
3261     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3262     return Some(expr2_0);
3263 }
3264 
3265 // Generated as internal constructor for term x64_mulps.
3266 pub fn constructor_x64_mulps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3267     let pattern0_0 = arg0;
3268     let pattern1_0 = arg1;
3269     // Rule at src/isa/x64/inst.isle line 2057.
3270     let expr0_0: Type = F32;
3271     let expr1_0 = SseOpcode::Mulps;
3272     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3273     return Some(expr2_0);
3274 }
3275 
3276 // Generated as internal constructor for term x64_mulpd.
3277 pub fn constructor_x64_mulpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3278     let pattern0_0 = arg0;
3279     let pattern1_0 = arg1;
3280     // Rule at src/isa/x64/inst.isle line 2062.
3281     let expr0_0: Type = F32;
3282     let expr1_0 = SseOpcode::Mulpd;
3283     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3284     return Some(expr2_0);
3285 }
3286 
3287 // Generated as internal constructor for term x64_divss.
3288 pub fn constructor_x64_divss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3289     let pattern0_0 = arg0;
3290     let pattern1_0 = arg1;
3291     // Rule at src/isa/x64/inst.isle line 2067.
3292     let expr0_0: Type = F32;
3293     let expr1_0 = SseOpcode::Divss;
3294     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3295     return Some(expr2_0);
3296 }
3297 
3298 // Generated as internal constructor for term x64_divsd.
3299 pub fn constructor_x64_divsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3300     let pattern0_0 = arg0;
3301     let pattern1_0 = arg1;
3302     // Rule at src/isa/x64/inst.isle line 2072.
3303     let expr0_0: Type = F64;
3304     let expr1_0 = SseOpcode::Divsd;
3305     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3306     return Some(expr2_0);
3307 }
3308 
3309 // Generated as internal constructor for term x64_divps.
3310 pub fn constructor_x64_divps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3311     let pattern0_0 = arg0;
3312     let pattern1_0 = arg1;
3313     // Rule at src/isa/x64/inst.isle line 2077.
3314     let expr0_0: Type = F32;
3315     let expr1_0 = SseOpcode::Divps;
3316     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3317     return Some(expr2_0);
3318 }
3319 
3320 // Generated as internal constructor for term x64_divpd.
3321 pub fn constructor_x64_divpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3322     let pattern0_0 = arg0;
3323     let pattern1_0 = arg1;
3324     // Rule at src/isa/x64/inst.isle line 2082.
3325     let expr0_0: Type = F32;
3326     let expr1_0 = SseOpcode::Divpd;
3327     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3328     return Some(expr2_0);
3329 }
3330 
3331 // Generated as internal constructor for term sse_blend_op.
3332 pub fn constructor_sse_blend_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3333     let pattern0_0 = arg0;
3334     if pattern0_0 == F32X4 {
3335         // Rule at src/isa/x64/inst.isle line 2086.
3336         let expr0_0 = SseOpcode::Blendvps;
3337         return Some(expr0_0);
3338     }
3339     if pattern0_0 == F64X2 {
3340         // Rule at src/isa/x64/inst.isle line 2087.
3341         let expr0_0 = SseOpcode::Blendvpd;
3342         return Some(expr0_0);
3343     }
3344     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3345         // Rule at src/isa/x64/inst.isle line 2088.
3346         let expr0_0 = SseOpcode::Pblendvb;
3347         return Some(expr0_0);
3348     }
3349     return None;
3350 }
3351 
3352 // Generated as internal constructor for term sse_mov_op.
3353 pub fn constructor_sse_mov_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3354     let pattern0_0 = arg0;
3355     if pattern0_0 == F32X4 {
3356         // Rule at src/isa/x64/inst.isle line 2091.
3357         let expr0_0 = SseOpcode::Movaps;
3358         return Some(expr0_0);
3359     }
3360     if pattern0_0 == F64X2 {
3361         // Rule at src/isa/x64/inst.isle line 2092.
3362         let expr0_0 = SseOpcode::Movapd;
3363         return Some(expr0_0);
3364     }
3365     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3366         // Rule at src/isa/x64/inst.isle line 2093.
3367         let expr0_0 = SseOpcode::Movdqa;
3368         return Some(expr0_0);
3369     }
3370     return None;
3371 }
3372 
3373 // Generated as internal constructor for term x64_blend.
3374 pub fn constructor_x64_blend<C: Context>(
3375     ctx: &mut C,
3376     arg0: Type,
3377     arg1: &XmmMem,
3378     arg2: &XmmMem,
3379     arg3: Xmm,
3380 ) -> Option<Xmm> {
3381     let pattern0_0 = arg0;
3382     let pattern1_0 = arg1;
3383     let pattern2_0 = arg2;
3384     let pattern3_0 = arg3;
3385     // Rule at src/isa/x64/inst.isle line 2097.
3386     let expr0_0 = C::xmm0(ctx);
3387     let expr1_0 = constructor_sse_mov_op(ctx, pattern0_0)?;
3388     let expr2_0 = MInst::XmmUnaryRmR {
3389         op: expr1_0,
3390         src: pattern1_0.clone(),
3391         dst: expr0_0,
3392     };
3393     let expr3_0 = C::emit(ctx, &expr2_0);
3394     let expr4_0 = constructor_sse_blend_op(ctx, pattern0_0)?;
3395     let expr5_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr4_0, pattern3_0, pattern2_0)?;
3396     return Some(expr5_0);
3397 }
3398 
3399 // Generated as internal constructor for term x64_blendvpd.
3400 pub fn constructor_x64_blendvpd<C: Context>(
3401     ctx: &mut C,
3402     arg0: Xmm,
3403     arg1: &XmmMem,
3404     arg2: Xmm,
3405 ) -> Option<Xmm> {
3406     let pattern0_0 = arg0;
3407     let pattern1_0 = arg1;
3408     let pattern2_0 = arg2;
3409     // Rule at src/isa/x64/inst.isle line 2111.
3410     let expr0_0 = C::xmm0(ctx);
3411     let expr1_0 = SseOpcode::Movapd;
3412     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern2_0);
3413     let expr3_0 = MInst::XmmUnaryRmR {
3414         op: expr1_0,
3415         src: expr2_0,
3416         dst: expr0_0,
3417     };
3418     let expr4_0 = C::emit(ctx, &expr3_0);
3419     let expr5_0: Type = F64X2;
3420     let expr6_0 = SseOpcode::Blendvpd;
3421     let expr7_0 = constructor_xmm_rm_r(ctx, expr5_0, &expr6_0, pattern0_0, pattern1_0)?;
3422     return Some(expr7_0);
3423 }
3424 
3425 // Generated as internal constructor for term x64_movsd_regmove.
3426 pub fn constructor_x64_movsd_regmove<C: Context>(
3427     ctx: &mut C,
3428     arg0: Xmm,
3429     arg1: &XmmMem,
3430 ) -> Option<Xmm> {
3431     let pattern0_0 = arg0;
3432     let pattern1_0 = arg1;
3433     // Rule at src/isa/x64/inst.isle line 2125.
3434     let expr0_0: Type = I8X16;
3435     let expr1_0 = SseOpcode::Movsd;
3436     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3437     return Some(expr2_0);
3438 }
3439 
3440 // Generated as internal constructor for term x64_movlhps.
3441 pub fn constructor_x64_movlhps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3442     let pattern0_0 = arg0;
3443     let pattern1_0 = arg1;
3444     // Rule at src/isa/x64/inst.isle line 2130.
3445     let expr0_0: Type = I8X16;
3446     let expr1_0 = SseOpcode::Movlhps;
3447     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3448     return Some(expr2_0);
3449 }
3450 
3451 // Generated as internal constructor for term x64_pmaxs.
3452 pub fn constructor_x64_pmaxs<C: Context>(
3453     ctx: &mut C,
3454     arg0: Type,
3455     arg1: Xmm,
3456     arg2: &XmmMem,
3457 ) -> Option<Xmm> {
3458     let pattern0_0 = arg0;
3459     if pattern0_0 == I8X16 {
3460         let pattern2_0 = arg1;
3461         let pattern3_0 = arg2;
3462         // Rule at src/isa/x64/inst.isle line 2135.
3463         let expr0_0 = constructor_x64_pmaxsb(ctx, pattern2_0, pattern3_0)?;
3464         return Some(expr0_0);
3465     }
3466     if pattern0_0 == I16X8 {
3467         let pattern2_0 = arg1;
3468         let pattern3_0 = arg2;
3469         // Rule at src/isa/x64/inst.isle line 2136.
3470         let expr0_0 = constructor_x64_pmaxsw(ctx, pattern2_0, pattern3_0)?;
3471         return Some(expr0_0);
3472     }
3473     if pattern0_0 == I32X4 {
3474         let pattern2_0 = arg1;
3475         let pattern3_0 = arg2;
3476         // Rule at src/isa/x64/inst.isle line 2137.
3477         let expr0_0 = constructor_x64_pmaxsd(ctx, pattern2_0, pattern3_0)?;
3478         return Some(expr0_0);
3479     }
3480     return None;
3481 }
3482 
3483 // Generated as internal constructor for term x64_pmaxsb.
3484 pub fn constructor_x64_pmaxsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3485     let pattern0_0 = arg0;
3486     let pattern1_0 = arg1;
3487     // Rule at src/isa/x64/inst.isle line 2140.
3488     let expr0_0: Type = I8X16;
3489     let expr1_0 = SseOpcode::Pmaxsb;
3490     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3491     return Some(expr2_0);
3492 }
3493 
3494 // Generated as internal constructor for term x64_pmaxsw.
3495 pub fn constructor_x64_pmaxsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3496     let pattern0_0 = arg0;
3497     let pattern1_0 = arg1;
3498     // Rule at src/isa/x64/inst.isle line 2142.
3499     let expr0_0: Type = I8X16;
3500     let expr1_0 = SseOpcode::Pmaxsw;
3501     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3502     return Some(expr2_0);
3503 }
3504 
3505 // Generated as internal constructor for term x64_pmaxsd.
3506 pub fn constructor_x64_pmaxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3507     let pattern0_0 = arg0;
3508     let pattern1_0 = arg1;
3509     // Rule at src/isa/x64/inst.isle line 2144.
3510     let expr0_0: Type = I8X16;
3511     let expr1_0 = SseOpcode::Pmaxsd;
3512     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3513     return Some(expr2_0);
3514 }
3515 
3516 // Generated as internal constructor for term x64_pmins.
3517 pub fn constructor_x64_pmins<C: Context>(
3518     ctx: &mut C,
3519     arg0: Type,
3520     arg1: Xmm,
3521     arg2: &XmmMem,
3522 ) -> Option<Xmm> {
3523     let pattern0_0 = arg0;
3524     if pattern0_0 == I8X16 {
3525         let pattern2_0 = arg1;
3526         let pattern3_0 = arg2;
3527         // Rule at src/isa/x64/inst.isle line 2148.
3528         let expr0_0 = constructor_x64_pminsb(ctx, pattern2_0, pattern3_0)?;
3529         return Some(expr0_0);
3530     }
3531     if pattern0_0 == I16X8 {
3532         let pattern2_0 = arg1;
3533         let pattern3_0 = arg2;
3534         // Rule at src/isa/x64/inst.isle line 2149.
3535         let expr0_0 = constructor_x64_pminsw(ctx, pattern2_0, pattern3_0)?;
3536         return Some(expr0_0);
3537     }
3538     if pattern0_0 == I32X4 {
3539         let pattern2_0 = arg1;
3540         let pattern3_0 = arg2;
3541         // Rule at src/isa/x64/inst.isle line 2150.
3542         let expr0_0 = constructor_x64_pminsd(ctx, pattern2_0, pattern3_0)?;
3543         return Some(expr0_0);
3544     }
3545     return None;
3546 }
3547 
3548 // Generated as internal constructor for term x64_pminsb.
3549 pub fn constructor_x64_pminsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3550     let pattern0_0 = arg0;
3551     let pattern1_0 = arg1;
3552     // Rule at src/isa/x64/inst.isle line 2153.
3553     let expr0_0: Type = I8X16;
3554     let expr1_0 = SseOpcode::Pminsb;
3555     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3556     return Some(expr2_0);
3557 }
3558 
3559 // Generated as internal constructor for term x64_pminsw.
3560 pub fn constructor_x64_pminsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3561     let pattern0_0 = arg0;
3562     let pattern1_0 = arg1;
3563     // Rule at src/isa/x64/inst.isle line 2155.
3564     let expr0_0: Type = I16X8;
3565     let expr1_0 = SseOpcode::Pminsw;
3566     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3567     return Some(expr2_0);
3568 }
3569 
3570 // Generated as internal constructor for term x64_pminsd.
3571 pub fn constructor_x64_pminsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3572     let pattern0_0 = arg0;
3573     let pattern1_0 = arg1;
3574     // Rule at src/isa/x64/inst.isle line 2157.
3575     let expr0_0: Type = I32X4;
3576     let expr1_0 = SseOpcode::Pminsd;
3577     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3578     return Some(expr2_0);
3579 }
3580 
3581 // Generated as internal constructor for term x64_pmaxu.
3582 pub fn constructor_x64_pmaxu<C: Context>(
3583     ctx: &mut C,
3584     arg0: Type,
3585     arg1: Xmm,
3586     arg2: &XmmMem,
3587 ) -> Option<Xmm> {
3588     let pattern0_0 = arg0;
3589     if pattern0_0 == I8X16 {
3590         let pattern2_0 = arg1;
3591         let pattern3_0 = arg2;
3592         // Rule at src/isa/x64/inst.isle line 2161.
3593         let expr0_0 = constructor_x64_pmaxub(ctx, pattern2_0, pattern3_0)?;
3594         return Some(expr0_0);
3595     }
3596     if pattern0_0 == I16X8 {
3597         let pattern2_0 = arg1;
3598         let pattern3_0 = arg2;
3599         // Rule at src/isa/x64/inst.isle line 2162.
3600         let expr0_0 = constructor_x64_pmaxuw(ctx, pattern2_0, pattern3_0)?;
3601         return Some(expr0_0);
3602     }
3603     if pattern0_0 == I32X4 {
3604         let pattern2_0 = arg1;
3605         let pattern3_0 = arg2;
3606         // Rule at src/isa/x64/inst.isle line 2163.
3607         let expr0_0 = constructor_x64_pmaxud(ctx, pattern2_0, pattern3_0)?;
3608         return Some(expr0_0);
3609     }
3610     return None;
3611 }
3612 
3613 // Generated as internal constructor for term x64_pmaxub.
3614 pub fn constructor_x64_pmaxub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3615     let pattern0_0 = arg0;
3616     let pattern1_0 = arg1;
3617     // Rule at src/isa/x64/inst.isle line 2166.
3618     let expr0_0: Type = I8X16;
3619     let expr1_0 = SseOpcode::Pmaxub;
3620     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3621     return Some(expr2_0);
3622 }
3623 
3624 // Generated as internal constructor for term x64_pmaxuw.
3625 pub fn constructor_x64_pmaxuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3626     let pattern0_0 = arg0;
3627     let pattern1_0 = arg1;
3628     // Rule at src/isa/x64/inst.isle line 2168.
3629     let expr0_0: Type = I8X16;
3630     let expr1_0 = SseOpcode::Pmaxuw;
3631     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3632     return Some(expr2_0);
3633 }
3634 
3635 // Generated as internal constructor for term x64_pmaxud.
3636 pub fn constructor_x64_pmaxud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3637     let pattern0_0 = arg0;
3638     let pattern1_0 = arg1;
3639     // Rule at src/isa/x64/inst.isle line 2170.
3640     let expr0_0: Type = I8X16;
3641     let expr1_0 = SseOpcode::Pmaxud;
3642     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3643     return Some(expr2_0);
3644 }
3645 
3646 // Generated as internal constructor for term x64_pminu.
3647 pub fn constructor_x64_pminu<C: Context>(
3648     ctx: &mut C,
3649     arg0: Type,
3650     arg1: Xmm,
3651     arg2: &XmmMem,
3652 ) -> Option<Xmm> {
3653     let pattern0_0 = arg0;
3654     if pattern0_0 == I8X16 {
3655         let pattern2_0 = arg1;
3656         let pattern3_0 = arg2;
3657         // Rule at src/isa/x64/inst.isle line 2174.
3658         let expr0_0 = constructor_x64_pminub(ctx, pattern2_0, pattern3_0)?;
3659         return Some(expr0_0);
3660     }
3661     if pattern0_0 == I16X8 {
3662         let pattern2_0 = arg1;
3663         let pattern3_0 = arg2;
3664         // Rule at src/isa/x64/inst.isle line 2175.
3665         let expr0_0 = constructor_x64_pminuw(ctx, pattern2_0, pattern3_0)?;
3666         return Some(expr0_0);
3667     }
3668     if pattern0_0 == I32X4 {
3669         let pattern2_0 = arg1;
3670         let pattern3_0 = arg2;
3671         // Rule at src/isa/x64/inst.isle line 2176.
3672         let expr0_0 = constructor_x64_pminud(ctx, pattern2_0, pattern3_0)?;
3673         return Some(expr0_0);
3674     }
3675     return None;
3676 }
3677 
3678 // Generated as internal constructor for term x64_pminub.
3679 pub fn constructor_x64_pminub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3680     let pattern0_0 = arg0;
3681     let pattern1_0 = arg1;
3682     // Rule at src/isa/x64/inst.isle line 2179.
3683     let expr0_0: Type = I8X16;
3684     let expr1_0 = SseOpcode::Pminub;
3685     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3686     return Some(expr2_0);
3687 }
3688 
3689 // Generated as internal constructor for term x64_pminuw.
3690 pub fn constructor_x64_pminuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3691     let pattern0_0 = arg0;
3692     let pattern1_0 = arg1;
3693     // Rule at src/isa/x64/inst.isle line 2181.
3694     let expr0_0: Type = I8X16;
3695     let expr1_0 = SseOpcode::Pminuw;
3696     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3697     return Some(expr2_0);
3698 }
3699 
3700 // Generated as internal constructor for term x64_pminud.
3701 pub fn constructor_x64_pminud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3702     let pattern0_0 = arg0;
3703     let pattern1_0 = arg1;
3704     // Rule at src/isa/x64/inst.isle line 2183.
3705     let expr0_0: Type = I8X16;
3706     let expr1_0 = SseOpcode::Pminud;
3707     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3708     return Some(expr2_0);
3709 }
3710 
3711 // Generated as internal constructor for term x64_punpcklbw.
3712 pub fn constructor_x64_punpcklbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3713     let pattern0_0 = arg0;
3714     let pattern1_0 = arg1;
3715     // Rule at src/isa/x64/inst.isle line 2187.
3716     let expr0_0: Type = I8X16;
3717     let expr1_0 = SseOpcode::Punpcklbw;
3718     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3719     return Some(expr2_0);
3720 }
3721 
3722 // Generated as internal constructor for term x64_punpckhbw.
3723 pub fn constructor_x64_punpckhbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3724     let pattern0_0 = arg0;
3725     let pattern1_0 = arg1;
3726     // Rule at src/isa/x64/inst.isle line 2192.
3727     let expr0_0: Type = I8X16;
3728     let expr1_0 = SseOpcode::Punpckhbw;
3729     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3730     return Some(expr2_0);
3731 }
3732 
3733 // Generated as internal constructor for term x64_packsswb.
3734 pub fn constructor_x64_packsswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3735     let pattern0_0 = arg0;
3736     let pattern1_0 = arg1;
3737     // Rule at src/isa/x64/inst.isle line 2197.
3738     let expr0_0: Type = I8X16;
3739     let expr1_0 = SseOpcode::Packsswb;
3740     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3741     return Some(expr2_0);
3742 }
3743 
3744 // Generated as internal constructor for term xmm_rm_r_imm.
3745 pub fn constructor_xmm_rm_r_imm<C: Context>(
3746     ctx: &mut C,
3747     arg0: &SseOpcode,
3748     arg1: Reg,
3749     arg2: &RegMem,
3750     arg3: u8,
3751     arg4: &OperandSize,
3752 ) -> Option<Xmm> {
3753     let pattern0_0 = arg0;
3754     let pattern1_0 = arg1;
3755     let pattern2_0 = arg2;
3756     let pattern3_0 = arg3;
3757     let pattern4_0 = arg4;
3758     // Rule at src/isa/x64/inst.isle line 2202.
3759     let expr0_0 = C::temp_writable_xmm(ctx);
3760     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
3761     let expr2_0 = MInst::XmmRmRImm {
3762         op: pattern0_0.clone(),
3763         src1: pattern1_0,
3764         src2: pattern2_0.clone(),
3765         dst: expr1_0,
3766         imm: pattern3_0,
3767         size: pattern4_0.clone(),
3768     };
3769     let expr3_0 = C::emit(ctx, &expr2_0);
3770     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3771     return Some(expr4_0);
3772 }
3773 
3774 // Generated as internal constructor for term x64_palignr.
3775 pub fn constructor_x64_palignr<C: Context>(
3776     ctx: &mut C,
3777     arg0: Xmm,
3778     arg1: &XmmMem,
3779     arg2: u8,
3780     arg3: &OperandSize,
3781 ) -> Option<Xmm> {
3782     let pattern0_0 = arg0;
3783     let pattern1_0 = arg1;
3784     let pattern2_0 = arg2;
3785     let pattern3_0 = arg3;
3786     // Rule at src/isa/x64/inst.isle line 2214.
3787     let expr0_0 = SseOpcode::Palignr;
3788     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3789     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3790     let expr3_0 =
3791         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
3792     return Some(expr3_0);
3793 }
3794 
3795 // Generated as internal constructor for term x64_cmpp.
3796 pub fn constructor_x64_cmpp<C: Context>(
3797     ctx: &mut C,
3798     arg0: Type,
3799     arg1: Xmm,
3800     arg2: &XmmMem,
3801     arg3: &FcmpImm,
3802 ) -> Option<Xmm> {
3803     let pattern0_0 = arg0;
3804     if pattern0_0 == F32X4 {
3805         let pattern2_0 = arg1;
3806         let pattern3_0 = arg2;
3807         let pattern4_0 = arg3;
3808         // Rule at src/isa/x64/inst.isle line 2223.
3809         let expr0_0 = constructor_x64_cmpps(ctx, pattern2_0, pattern3_0, pattern4_0)?;
3810         return Some(expr0_0);
3811     }
3812     if pattern0_0 == F64X2 {
3813         let pattern2_0 = arg1;
3814         let pattern3_0 = arg2;
3815         let pattern4_0 = arg3;
3816         // Rule at src/isa/x64/inst.isle line 2224.
3817         let expr0_0 = constructor_x64_cmppd(ctx, pattern2_0, pattern3_0, pattern4_0)?;
3818         return Some(expr0_0);
3819     }
3820     return None;
3821 }
3822 
3823 // Generated as internal constructor for term x64_cmpps.
3824 pub fn constructor_x64_cmpps<C: Context>(
3825     ctx: &mut C,
3826     arg0: Xmm,
3827     arg1: &XmmMem,
3828     arg2: &FcmpImm,
3829 ) -> Option<Xmm> {
3830     let pattern0_0 = arg0;
3831     let pattern1_0 = arg1;
3832     let pattern2_0 = arg2;
3833     // Rule at src/isa/x64/inst.isle line 2227.
3834     let expr0_0 = SseOpcode::Cmpps;
3835     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3836     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3837     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
3838     let expr4_0 = OperandSize::Size32;
3839     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
3840     return Some(expr5_0);
3841 }
3842 
3843 // Generated as internal constructor for term x64_cmppd.
3844 pub fn constructor_x64_cmppd<C: Context>(
3845     ctx: &mut C,
3846     arg0: Xmm,
3847     arg1: &XmmMem,
3848     arg2: &FcmpImm,
3849 ) -> Option<Xmm> {
3850     let pattern0_0 = arg0;
3851     let pattern1_0 = arg1;
3852     let pattern2_0 = arg2;
3853     // Rule at src/isa/x64/inst.isle line 2238.
3854     let expr0_0 = SseOpcode::Cmppd;
3855     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3856     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3857     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
3858     let expr4_0 = OperandSize::Size32;
3859     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
3860     return Some(expr5_0);
3861 }
3862 
3863 // Generated as internal constructor for term x64_pinsrb.
3864 pub fn constructor_x64_pinsrb<C: Context>(
3865     ctx: &mut C,
3866     arg0: Xmm,
3867     arg1: &GprMem,
3868     arg2: u8,
3869 ) -> Option<Xmm> {
3870     let pattern0_0 = arg0;
3871     let pattern1_0 = arg1;
3872     let pattern2_0 = arg2;
3873     // Rule at src/isa/x64/inst.isle line 2247.
3874     let expr0_0 = SseOpcode::Pinsrb;
3875     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3876     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3877     let expr3_0 = OperandSize::Size32;
3878     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3879     return Some(expr4_0);
3880 }
3881 
3882 // Generated as internal constructor for term x64_pinsrw.
3883 pub fn constructor_x64_pinsrw<C: Context>(
3884     ctx: &mut C,
3885     arg0: Xmm,
3886     arg1: &GprMem,
3887     arg2: u8,
3888 ) -> Option<Xmm> {
3889     let pattern0_0 = arg0;
3890     let pattern1_0 = arg1;
3891     let pattern2_0 = arg2;
3892     // Rule at src/isa/x64/inst.isle line 2256.
3893     let expr0_0 = SseOpcode::Pinsrw;
3894     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3895     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3896     let expr3_0 = OperandSize::Size32;
3897     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3898     return Some(expr4_0);
3899 }
3900 
3901 // Generated as internal constructor for term x64_pinsrd.
3902 pub fn constructor_x64_pinsrd<C: Context>(
3903     ctx: &mut C,
3904     arg0: Xmm,
3905     arg1: &GprMem,
3906     arg2: u8,
3907     arg3: &OperandSize,
3908 ) -> Option<Xmm> {
3909     let pattern0_0 = arg0;
3910     let pattern1_0 = arg1;
3911     let pattern2_0 = arg2;
3912     let pattern3_0 = arg3;
3913     // Rule at src/isa/x64/inst.isle line 2265.
3914     let expr0_0 = SseOpcode::Pinsrd;
3915     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3916     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3917     let expr3_0 =
3918         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
3919     return Some(expr3_0);
3920 }
3921 
3922 // Generated as internal constructor for term x64_pmaddwd.
3923 pub fn constructor_x64_pmaddwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3924     let pattern0_0 = arg0;
3925     let pattern1_0 = arg1;
3926     // Rule at src/isa/x64/inst.isle line 2274.
3927     let expr0_0 = C::temp_writable_xmm(ctx);
3928     let expr1_0 = SseOpcode::Pmaddwd;
3929     let expr2_0 = MInst::XmmRmR {
3930         op: expr1_0,
3931         src1: pattern0_0,
3932         src2: pattern1_0.clone(),
3933         dst: expr0_0,
3934     };
3935     let expr3_0 = C::emit(ctx, &expr2_0);
3936     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3937     return Some(expr4_0);
3938 }
3939 
3940 // Generated as internal constructor for term x64_insertps.
3941 pub fn constructor_x64_insertps<C: Context>(
3942     ctx: &mut C,
3943     arg0: Xmm,
3944     arg1: &XmmMem,
3945     arg2: u8,
3946 ) -> Option<Xmm> {
3947     let pattern0_0 = arg0;
3948     let pattern1_0 = arg1;
3949     let pattern2_0 = arg2;
3950     // Rule at src/isa/x64/inst.isle line 2284.
3951     let expr0_0 = SseOpcode::Insertps;
3952     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3953     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3954     let expr3_0 = OperandSize::Size32;
3955     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3956     return Some(expr4_0);
3957 }
3958 
3959 // Generated as internal constructor for term x64_pshufd.
3960 pub fn constructor_x64_pshufd<C: Context>(
3961     ctx: &mut C,
3962     arg0: &XmmMem,
3963     arg1: u8,
3964     arg2: &OperandSize,
3965 ) -> Option<Xmm> {
3966     let pattern0_0 = arg0;
3967     let pattern1_0 = arg1;
3968     let pattern2_0 = arg2;
3969     // Rule at src/isa/x64/inst.isle line 2293.
3970     let expr0_0 = C::temp_writable_xmm(ctx);
3971     let expr1_0 = SseOpcode::Pshufd;
3972     let expr2_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
3973     let expr3_0 = C::xmm_mem_to_reg_mem(ctx, pattern0_0);
3974     let expr4_0 = C::writable_xmm_to_reg(ctx, expr0_0);
3975     let expr5_0 = MInst::XmmRmRImm {
3976         op: expr1_0,
3977         src1: expr2_0,
3978         src2: expr3_0,
3979         dst: expr4_0,
3980         imm: pattern1_0,
3981         size: pattern2_0.clone(),
3982     };
3983     let expr6_0 = C::emit(ctx, &expr5_0);
3984     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3985     return Some(expr7_0);
3986 }
3987 
3988 // Generated as internal constructor for term x64_pshufb.
3989 pub fn constructor_x64_pshufb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3990     let pattern0_0 = arg0;
3991     let pattern1_0 = arg1;
3992     // Rule at src/isa/x64/inst.isle line 2305.
3993     let expr0_0 = C::temp_writable_xmm(ctx);
3994     let expr1_0 = SseOpcode::Pshufb;
3995     let expr2_0 = MInst::XmmRmR {
3996         op: expr1_0,
3997         src1: pattern0_0,
3998         src2: pattern1_0.clone(),
3999         dst: expr0_0,
4000     };
4001     let expr3_0 = C::emit(ctx, &expr2_0);
4002     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4003     return Some(expr4_0);
4004 }
4005 
4006 // Generated as internal constructor for term xmm_unary_rm_r.
4007 pub fn constructor_xmm_unary_rm_r<C: Context>(
4008     ctx: &mut C,
4009     arg0: &SseOpcode,
4010     arg1: &XmmMem,
4011 ) -> Option<Xmm> {
4012     let pattern0_0 = arg0;
4013     let pattern1_0 = arg1;
4014     // Rule at src/isa/x64/inst.isle line 2315.
4015     let expr0_0 = C::temp_writable_xmm(ctx);
4016     let expr1_0 = MInst::XmmUnaryRmR {
4017         op: pattern0_0.clone(),
4018         src: pattern1_0.clone(),
4019         dst: expr0_0,
4020     };
4021     let expr2_0 = C::emit(ctx, &expr1_0);
4022     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4023     return Some(expr3_0);
4024 }
4025 
4026 // Generated as internal constructor for term x64_pabsb.
4027 pub fn constructor_x64_pabsb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4028     let pattern0_0 = arg0;
4029     // Rule at src/isa/x64/inst.isle line 2322.
4030     let expr0_0 = SseOpcode::Pabsb;
4031     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4032     return Some(expr1_0);
4033 }
4034 
4035 // Generated as internal constructor for term x64_pabsw.
4036 pub fn constructor_x64_pabsw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4037     let pattern0_0 = arg0;
4038     // Rule at src/isa/x64/inst.isle line 2327.
4039     let expr0_0 = SseOpcode::Pabsw;
4040     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4041     return Some(expr1_0);
4042 }
4043 
4044 // Generated as internal constructor for term x64_pabsd.
4045 pub fn constructor_x64_pabsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4046     let pattern0_0 = arg0;
4047     // Rule at src/isa/x64/inst.isle line 2332.
4048     let expr0_0 = SseOpcode::Pabsd;
4049     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4050     return Some(expr1_0);
4051 }
4052 
4053 // Generated as internal constructor for term xmm_unary_rm_r_evex.
4054 pub fn constructor_xmm_unary_rm_r_evex<C: Context>(
4055     ctx: &mut C,
4056     arg0: &Avx512Opcode,
4057     arg1: &XmmMem,
4058 ) -> Option<Xmm> {
4059     let pattern0_0 = arg0;
4060     let pattern1_0 = arg1;
4061     // Rule at src/isa/x64/inst.isle line 2337.
4062     let expr0_0 = C::temp_writable_xmm(ctx);
4063     let expr1_0 = MInst::XmmUnaryRmREvex {
4064         op: pattern0_0.clone(),
4065         src: pattern1_0.clone(),
4066         dst: expr0_0,
4067     };
4068     let expr2_0 = C::emit(ctx, &expr1_0);
4069     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4070     return Some(expr3_0);
4071 }
4072 
4073 // Generated as internal constructor for term x64_vpabsq.
4074 pub fn constructor_x64_vpabsq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4075     let pattern0_0 = arg0;
4076     // Rule at src/isa/x64/inst.isle line 2344.
4077     let expr0_0 = Avx512Opcode::Vpabsq;
4078     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4079     return Some(expr1_0);
4080 }
4081 
4082 // Generated as internal constructor for term x64_vpopcntb.
4083 pub fn constructor_x64_vpopcntb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4084     let pattern0_0 = arg0;
4085     // Rule at src/isa/x64/inst.isle line 2349.
4086     let expr0_0 = Avx512Opcode::Vpopcntb;
4087     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4088     return Some(expr1_0);
4089 }
4090 
4091 // Generated as internal constructor for term xmm_rm_r_evex.
4092 pub fn constructor_xmm_rm_r_evex<C: Context>(
4093     ctx: &mut C,
4094     arg0: &Avx512Opcode,
4095     arg1: &XmmMem,
4096     arg2: Xmm,
4097 ) -> Option<Xmm> {
4098     let pattern0_0 = arg0;
4099     let pattern1_0 = arg1;
4100     let pattern2_0 = arg2;
4101     // Rule at src/isa/x64/inst.isle line 2354.
4102     let expr0_0 = C::temp_writable_xmm(ctx);
4103     let expr1_0 = MInst::XmmRmREvex {
4104         op: pattern0_0.clone(),
4105         src1: pattern1_0.clone(),
4106         src2: pattern2_0,
4107         dst: expr0_0,
4108     };
4109     let expr2_0 = C::emit(ctx, &expr1_0);
4110     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4111     return Some(expr3_0);
4112 }
4113 
4114 // Generated as internal constructor for term x64_vpmullq.
4115 pub fn constructor_x64_vpmullq<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> Option<Xmm> {
4116     let pattern0_0 = arg0;
4117     let pattern1_0 = arg1;
4118     // Rule at src/isa/x64/inst.isle line 2366.
4119     let expr0_0 = Avx512Opcode::Vpmullq;
4120     let expr1_0 = constructor_xmm_rm_r_evex(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4121     return Some(expr1_0);
4122 }
4123 
4124 // Generated as internal constructor for term mul_hi.
4125 pub fn constructor_mul_hi<C: Context>(
4126     ctx: &mut C,
4127     arg0: Type,
4128     arg1: bool,
4129     arg2: Gpr,
4130     arg3: &GprMem,
4131 ) -> Option<ValueRegs> {
4132     let pattern0_0 = arg0;
4133     let pattern1_0 = arg1;
4134     let pattern2_0 = arg2;
4135     let pattern3_0 = arg3;
4136     // Rule at src/isa/x64/inst.isle line 2375.
4137     let expr0_0 = C::temp_writable_gpr(ctx);
4138     let expr1_0 = C::temp_writable_gpr(ctx);
4139     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4140     let expr3_0 = MInst::MulHi {
4141         size: expr2_0,
4142         signed: pattern1_0,
4143         src1: pattern2_0,
4144         src2: pattern3_0.clone(),
4145         dst_lo: expr0_0,
4146         dst_hi: expr1_0,
4147     };
4148     let expr4_0 = C::emit(ctx, &expr3_0);
4149     let expr5_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4150     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
4151     let expr7_0 = constructor_value_gprs(ctx, expr5_0, expr6_0)?;
4152     return Some(expr7_0);
4153 }
4154 
4155 // Generated as internal constructor for term mulhi_u.
4156 pub fn constructor_mulhi_u<C: Context>(
4157     ctx: &mut C,
4158     arg0: Type,
4159     arg1: Gpr,
4160     arg2: &GprMem,
4161 ) -> Option<ValueRegs> {
4162     let pattern0_0 = arg0;
4163     let pattern1_0 = arg1;
4164     let pattern2_0 = arg2;
4165     // Rule at src/isa/x64/inst.isle line 2390.
4166     let expr0_0: bool = false;
4167     let expr1_0 = constructor_mul_hi(ctx, pattern0_0, expr0_0, pattern1_0, pattern2_0)?;
4168     return Some(expr1_0);
4169 }
4170 
4171 // Generated as internal constructor for term xmm_rmi_xmm.
4172 pub fn constructor_xmm_rmi_xmm<C: Context>(
4173     ctx: &mut C,
4174     arg0: &SseOpcode,
4175     arg1: Xmm,
4176     arg2: &XmmMemImm,
4177 ) -> Option<Xmm> {
4178     let pattern0_0 = arg0;
4179     let pattern1_0 = arg1;
4180     let pattern2_0 = arg2;
4181     // Rule at src/isa/x64/inst.isle line 2395.
4182     let expr0_0 = C::temp_writable_xmm(ctx);
4183     let expr1_0 = MInst::XmmRmiReg {
4184         opcode: pattern0_0.clone(),
4185         src1: pattern1_0,
4186         src2: pattern2_0.clone(),
4187         dst: expr0_0,
4188     };
4189     let expr2_0 = C::emit(ctx, &expr1_0);
4190     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4191     return Some(expr3_0);
4192 }
4193 
4194 // Generated as internal constructor for term x64_psllw.
4195 pub fn constructor_x64_psllw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4196     let pattern0_0 = arg0;
4197     let pattern1_0 = arg1;
4198     // Rule at src/isa/x64/inst.isle line 2405.
4199     let expr0_0 = SseOpcode::Psllw;
4200     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4201     return Some(expr1_0);
4202 }
4203 
4204 // Generated as internal constructor for term x64_pslld.
4205 pub fn constructor_x64_pslld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4206     let pattern0_0 = arg0;
4207     let pattern1_0 = arg1;
4208     // Rule at src/isa/x64/inst.isle line 2410.
4209     let expr0_0 = SseOpcode::Pslld;
4210     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4211     return Some(expr1_0);
4212 }
4213 
4214 // Generated as internal constructor for term x64_psllq.
4215 pub fn constructor_x64_psllq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4216     let pattern0_0 = arg0;
4217     let pattern1_0 = arg1;
4218     // Rule at src/isa/x64/inst.isle line 2415.
4219     let expr0_0 = SseOpcode::Psllq;
4220     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4221     return Some(expr1_0);
4222 }
4223 
4224 // Generated as internal constructor for term x64_psrlw.
4225 pub fn constructor_x64_psrlw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4226     let pattern0_0 = arg0;
4227     let pattern1_0 = arg1;
4228     // Rule at src/isa/x64/inst.isle line 2420.
4229     let expr0_0 = SseOpcode::Psrlw;
4230     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4231     return Some(expr1_0);
4232 }
4233 
4234 // Generated as internal constructor for term x64_psrld.
4235 pub fn constructor_x64_psrld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4236     let pattern0_0 = arg0;
4237     let pattern1_0 = arg1;
4238     // Rule at src/isa/x64/inst.isle line 2425.
4239     let expr0_0 = SseOpcode::Psrld;
4240     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4241     return Some(expr1_0);
4242 }
4243 
4244 // Generated as internal constructor for term x64_psrlq.
4245 pub fn constructor_x64_psrlq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4246     let pattern0_0 = arg0;
4247     let pattern1_0 = arg1;
4248     // Rule at src/isa/x64/inst.isle line 2430.
4249     let expr0_0 = SseOpcode::Psrlq;
4250     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4251     return Some(expr1_0);
4252 }
4253 
4254 // Generated as internal constructor for term x64_psraw.
4255 pub fn constructor_x64_psraw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4256     let pattern0_0 = arg0;
4257     let pattern1_0 = arg1;
4258     // Rule at src/isa/x64/inst.isle line 2435.
4259     let expr0_0 = SseOpcode::Psraw;
4260     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4261     return Some(expr1_0);
4262 }
4263 
4264 // Generated as internal constructor for term x64_psrad.
4265 pub fn constructor_x64_psrad<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4266     let pattern0_0 = arg0;
4267     let pattern1_0 = arg1;
4268     // Rule at src/isa/x64/inst.isle line 2440.
4269     let expr0_0 = SseOpcode::Psrad;
4270     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4271     return Some(expr1_0);
4272 }
4273 
4274 // Generated as internal constructor for term x64_pextrd.
4275 pub fn constructor_x64_pextrd<C: Context>(
4276     ctx: &mut C,
4277     arg0: Type,
4278     arg1: Xmm,
4279     arg2: u8,
4280 ) -> Option<Gpr> {
4281     let pattern0_0 = arg0;
4282     let pattern1_0 = arg1;
4283     let pattern2_0 = arg2;
4284     // Rule at src/isa/x64/inst.isle line 2445.
4285     let expr0_0 = C::temp_writable_gpr(ctx);
4286     let expr1_0 = SseOpcode::Pextrd;
4287     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4288     let expr3_0 = C::xmm_to_reg(ctx, pattern1_0);
4289     let expr4_0 = constructor_xmm_to_reg_mem(ctx, expr3_0)?;
4290     let expr5_0 = C::xmm_mem_to_reg_mem(ctx, &expr4_0);
4291     let expr6_0 = C::writable_gpr_to_reg(ctx, expr0_0);
4292     let expr7_0 = C::lane_type(ctx, pattern0_0);
4293     let expr8_0 = C::operand_size_of_type_32_64(ctx, expr7_0);
4294     let expr9_0 = MInst::XmmRmRImm {
4295         op: expr1_0,
4296         src1: expr2_0,
4297         src2: expr5_0,
4298         dst: expr6_0,
4299         imm: pattern2_0,
4300         size: expr8_0,
4301     };
4302     let expr10_0 = C::emit(ctx, &expr9_0);
4303     let expr11_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4304     return Some(expr11_0);
4305 }
4306 
4307 // Generated as internal constructor for term gpr_to_xmm.
4308 pub fn constructor_gpr_to_xmm<C: Context>(
4309     ctx: &mut C,
4310     arg0: &SseOpcode,
4311     arg1: &GprMem,
4312     arg2: &OperandSize,
4313 ) -> Option<Xmm> {
4314     let pattern0_0 = arg0;
4315     let pattern1_0 = arg1;
4316     let pattern2_0 = arg2;
4317     // Rule at src/isa/x64/inst.isle line 2457.
4318     let expr0_0 = C::temp_writable_xmm(ctx);
4319     let expr1_0 = MInst::GprToXmm {
4320         op: pattern0_0.clone(),
4321         src: pattern1_0.clone(),
4322         dst: expr0_0,
4323         src_size: pattern2_0.clone(),
4324     };
4325     let expr2_0 = C::emit(ctx, &expr1_0);
4326     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4327     return Some(expr3_0);
4328 }
4329 
4330 // Generated as internal constructor for term x64_not.
4331 pub fn constructor_x64_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4332     let pattern0_0 = arg0;
4333     let pattern1_0 = arg1;
4334     // Rule at src/isa/x64/inst.isle line 2464.
4335     let expr0_0 = C::temp_writable_gpr(ctx);
4336     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4337     let expr2_0 = MInst::Not {
4338         size: expr1_0,
4339         src: pattern1_0,
4340         dst: expr0_0,
4341     };
4342     let expr3_0 = C::emit(ctx, &expr2_0);
4343     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4344     return Some(expr4_0);
4345 }
4346 
4347 // Generated as internal constructor for term x64_neg.
4348 pub fn constructor_x64_neg<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4349     let pattern0_0 = arg0;
4350     let pattern1_0 = arg1;
4351     // Rule at src/isa/x64/inst.isle line 2472.
4352     let expr0_0 = C::temp_writable_gpr(ctx);
4353     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4354     let expr2_0 = MInst::Neg {
4355         size: expr1_0,
4356         src: pattern1_0,
4357         dst: expr0_0,
4358     };
4359     let expr3_0 = C::emit(ctx, &expr2_0);
4360     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4361     return Some(expr4_0);
4362 }
4363 
4364 // Generated as internal constructor for term x64_lea.
4365 pub fn constructor_x64_lea<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Option<Gpr> {
4366     let pattern0_0 = arg0;
4367     // Rule at src/isa/x64/inst.isle line 2479.
4368     let expr0_0 = C::temp_writable_gpr(ctx);
4369     let expr1_0 = MInst::LoadEffectiveAddress {
4370         addr: pattern0_0.clone(),
4371         dst: expr0_0,
4372     };
4373     let expr2_0 = C::emit(ctx, &expr1_0);
4374     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4375     return Some(expr3_0);
4376 }
4377 
4378 // Generated as internal constructor for term x64_ud2.
4379 pub fn constructor_x64_ud2<C: Context>(ctx: &mut C, arg0: &TrapCode) -> Option<SideEffectNoResult> {
4380     let pattern0_0 = arg0;
4381     // Rule at src/isa/x64/inst.isle line 2486.
4382     let expr0_0 = MInst::Ud2 {
4383         trap_code: pattern0_0.clone(),
4384     };
4385     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4386     return Some(expr1_0);
4387 }
4388 
4389 // Generated as internal constructor for term x64_hlt.
4390 pub fn constructor_x64_hlt<C: Context>(ctx: &mut C) -> Option<SideEffectNoResult> {
4391     // Rule at src/isa/x64/inst.isle line 2491.
4392     let expr0_0 = MInst::Hlt;
4393     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4394     return Some(expr1_0);
4395 }
4396 
4397 // Generated as internal constructor for term x64_lzcnt.
4398 pub fn constructor_x64_lzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4399     let pattern0_0 = arg0;
4400     let pattern1_0 = arg1;
4401     // Rule at src/isa/x64/inst.isle line 2496.
4402     let expr0_0 = C::temp_writable_gpr(ctx);
4403     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4404     let expr2_0 = UnaryRmROpcode::Lzcnt;
4405     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4406     let expr4_0 = MInst::UnaryRmR {
4407         size: expr1_0,
4408         op: expr2_0,
4409         src: expr3_0,
4410         dst: expr0_0,
4411     };
4412     let expr5_0 = C::emit(ctx, &expr4_0);
4413     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4414     return Some(expr6_0);
4415 }
4416 
4417 // Generated as internal constructor for term x64_tzcnt.
4418 pub fn constructor_x64_tzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4419     let pattern0_0 = arg0;
4420     let pattern1_0 = arg1;
4421     // Rule at src/isa/x64/inst.isle line 2504.
4422     let expr0_0 = C::temp_writable_gpr(ctx);
4423     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4424     let expr2_0 = UnaryRmROpcode::Tzcnt;
4425     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4426     let expr4_0 = MInst::UnaryRmR {
4427         size: expr1_0,
4428         op: expr2_0,
4429         src: expr3_0,
4430         dst: expr0_0,
4431     };
4432     let expr5_0 = C::emit(ctx, &expr4_0);
4433     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4434     return Some(expr6_0);
4435 }
4436 
4437 // Generated as internal constructor for term x64_bsr.
4438 pub fn constructor_x64_bsr<C: Context>(
4439     ctx: &mut C,
4440     arg0: Type,
4441     arg1: Gpr,
4442 ) -> Option<ProducesFlags> {
4443     let pattern0_0 = arg0;
4444     let pattern1_0 = arg1;
4445     // Rule at src/isa/x64/inst.isle line 2512.
4446     let expr0_0 = C::temp_writable_gpr(ctx);
4447     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4448     let expr2_0 = UnaryRmROpcode::Bsr;
4449     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4450     let expr4_0 = MInst::UnaryRmR {
4451         size: expr1_0,
4452         op: expr2_0,
4453         src: expr3_0,
4454         dst: expr0_0,
4455     };
4456     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4457     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4458         inst: expr4_0,
4459         result: expr5_0,
4460     };
4461     return Some(expr6_0);
4462 }
4463 
4464 // Generated as internal constructor for term bsr_or_else.
4465 pub fn constructor_bsr_or_else<C: Context>(
4466     ctx: &mut C,
4467     arg0: Type,
4468     arg1: Gpr,
4469     arg2: Gpr,
4470 ) -> Option<Gpr> {
4471     let pattern0_0 = arg0;
4472     let pattern1_0 = arg1;
4473     let pattern2_0 = arg2;
4474     // Rule at src/isa/x64/inst.isle line 2521.
4475     let expr0_0 = constructor_x64_bsr(ctx, pattern0_0, pattern1_0)?;
4476     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4477     let expr2_0 = C::gpr_new(ctx, expr1_0);
4478     let expr3_0 = CC::Z;
4479     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4480     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4481     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4482     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4483     let expr8_0 = C::gpr_new(ctx, expr7_0);
4484     return Some(expr8_0);
4485 }
4486 
4487 // Generated as internal constructor for term x64_bsf.
4488 pub fn constructor_x64_bsf<C: Context>(
4489     ctx: &mut C,
4490     arg0: Type,
4491     arg1: Gpr,
4492 ) -> Option<ProducesFlags> {
4493     let pattern0_0 = arg0;
4494     let pattern1_0 = arg1;
4495     // Rule at src/isa/x64/inst.isle line 2532.
4496     let expr0_0 = C::temp_writable_gpr(ctx);
4497     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4498     let expr2_0 = UnaryRmROpcode::Bsf;
4499     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4500     let expr4_0 = MInst::UnaryRmR {
4501         size: expr1_0,
4502         op: expr2_0,
4503         src: expr3_0,
4504         dst: expr0_0,
4505     };
4506     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4507     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4508         inst: expr4_0,
4509         result: expr5_0,
4510     };
4511     return Some(expr6_0);
4512 }
4513 
4514 // Generated as internal constructor for term bsf_or_else.
4515 pub fn constructor_bsf_or_else<C: Context>(
4516     ctx: &mut C,
4517     arg0: Type,
4518     arg1: Gpr,
4519     arg2: Gpr,
4520 ) -> Option<Gpr> {
4521     let pattern0_0 = arg0;
4522     let pattern1_0 = arg1;
4523     let pattern2_0 = arg2;
4524     // Rule at src/isa/x64/inst.isle line 2541.
4525     let expr0_0 = constructor_x64_bsf(ctx, pattern0_0, pattern1_0)?;
4526     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4527     let expr2_0 = C::gpr_new(ctx, expr1_0);
4528     let expr3_0 = CC::Z;
4529     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4530     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4531     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4532     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4533     let expr8_0 = C::gpr_new(ctx, expr7_0);
4534     return Some(expr8_0);
4535 }
4536 
4537 // Generated as internal constructor for term x64_popcnt.
4538 pub fn constructor_x64_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4539     let pattern0_0 = arg0;
4540     let pattern1_0 = arg1;
4541     // Rule at src/isa/x64/inst.isle line 2552.
4542     let expr0_0 = C::temp_writable_gpr(ctx);
4543     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4544     let expr2_0 = UnaryRmROpcode::Popcnt;
4545     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4546     let expr4_0 = MInst::UnaryRmR {
4547         size: expr1_0,
4548         op: expr2_0,
4549         src: expr3_0,
4550         dst: expr0_0,
4551     };
4552     let expr5_0 = C::emit(ctx, &expr4_0);
4553     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4554     return Some(expr6_0);
4555 }
4556 
4557 // Generated as internal constructor for term xmm_min_max_seq.
4558 pub fn constructor_xmm_min_max_seq<C: Context>(
4559     ctx: &mut C,
4560     arg0: Type,
4561     arg1: bool,
4562     arg2: Xmm,
4563     arg3: Xmm,
4564 ) -> Option<Xmm> {
4565     let pattern0_0 = arg0;
4566     let pattern1_0 = arg1;
4567     let pattern2_0 = arg2;
4568     let pattern3_0 = arg3;
4569     // Rule at src/isa/x64/inst.isle line 2560.
4570     let expr0_0 = C::temp_writable_xmm(ctx);
4571     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4572     let expr2_0 = MInst::XmmMinMaxSeq {
4573         size: expr1_0,
4574         is_min: pattern1_0,
4575         lhs: pattern2_0,
4576         rhs: pattern3_0,
4577         dst: expr0_0,
4578     };
4579     let expr3_0 = C::emit(ctx, &expr2_0);
4580     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4581     return Some(expr4_0);
4582 }
4583 
4584 // Generated as internal constructor for term x64_minss.
4585 pub fn constructor_x64_minss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4586     let pattern0_0 = arg0;
4587     let pattern1_0 = arg1;
4588     // Rule at src/isa/x64/inst.isle line 2568.
4589     let expr0_0 = C::temp_writable_xmm(ctx);
4590     let expr1_0 = SseOpcode::Minss;
4591     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4592     let expr3_0 = MInst::XmmRmR {
4593         op: expr1_0,
4594         src1: pattern0_0,
4595         src2: expr2_0,
4596         dst: expr0_0,
4597     };
4598     let expr4_0 = C::emit(ctx, &expr3_0);
4599     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4600     return Some(expr5_0);
4601 }
4602 
4603 // Generated as internal constructor for term x64_minsd.
4604 pub fn constructor_x64_minsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4605     let pattern0_0 = arg0;
4606     let pattern1_0 = arg1;
4607     // Rule at src/isa/x64/inst.isle line 2575.
4608     let expr0_0 = C::temp_writable_xmm(ctx);
4609     let expr1_0 = SseOpcode::Minsd;
4610     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4611     let expr3_0 = MInst::XmmRmR {
4612         op: expr1_0,
4613         src1: pattern0_0,
4614         src2: expr2_0,
4615         dst: expr0_0,
4616     };
4617     let expr4_0 = C::emit(ctx, &expr3_0);
4618     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4619     return Some(expr5_0);
4620 }
4621 
4622 // Generated as internal constructor for term x64_minps.
4623 pub fn constructor_x64_minps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4624     let pattern0_0 = arg0;
4625     let pattern1_0 = arg1;
4626     // Rule at src/isa/x64/inst.isle line 2583.
4627     let expr0_0 = C::temp_writable_xmm(ctx);
4628     let expr1_0 = SseOpcode::Minps;
4629     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4630     let expr3_0 = MInst::XmmRmR {
4631         op: expr1_0,
4632         src1: pattern0_0,
4633         src2: expr2_0,
4634         dst: expr0_0,
4635     };
4636     let expr4_0 = C::emit(ctx, &expr3_0);
4637     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4638     return Some(expr5_0);
4639 }
4640 
4641 // Generated as internal constructor for term x64_minpd.
4642 pub fn constructor_x64_minpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4643     let pattern0_0 = arg0;
4644     let pattern1_0 = arg1;
4645     // Rule at src/isa/x64/inst.isle line 2590.
4646     let expr0_0 = C::temp_writable_xmm(ctx);
4647     let expr1_0 = SseOpcode::Minpd;
4648     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4649     let expr3_0 = MInst::XmmRmR {
4650         op: expr1_0,
4651         src1: pattern0_0,
4652         src2: expr2_0,
4653         dst: expr0_0,
4654     };
4655     let expr4_0 = C::emit(ctx, &expr3_0);
4656     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4657     return Some(expr5_0);
4658 }
4659 
4660 // Generated as internal constructor for term x64_maxss.
4661 pub fn constructor_x64_maxss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4662     let pattern0_0 = arg0;
4663     let pattern1_0 = arg1;
4664     // Rule at src/isa/x64/inst.isle line 2597.
4665     let expr0_0 = C::temp_writable_xmm(ctx);
4666     let expr1_0 = SseOpcode::Maxss;
4667     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4668     let expr3_0 = MInst::XmmRmR {
4669         op: expr1_0,
4670         src1: pattern0_0,
4671         src2: expr2_0,
4672         dst: expr0_0,
4673     };
4674     let expr4_0 = C::emit(ctx, &expr3_0);
4675     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4676     return Some(expr5_0);
4677 }
4678 
4679 // Generated as internal constructor for term x64_maxsd.
4680 pub fn constructor_x64_maxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4681     let pattern0_0 = arg0;
4682     let pattern1_0 = arg1;
4683     // Rule at src/isa/x64/inst.isle line 2604.
4684     let expr0_0 = C::temp_writable_xmm(ctx);
4685     let expr1_0 = SseOpcode::Maxsd;
4686     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4687     let expr3_0 = MInst::XmmRmR {
4688         op: expr1_0,
4689         src1: pattern0_0,
4690         src2: expr2_0,
4691         dst: expr0_0,
4692     };
4693     let expr4_0 = C::emit(ctx, &expr3_0);
4694     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4695     return Some(expr5_0);
4696 }
4697 
4698 // Generated as internal constructor for term x64_maxps.
4699 pub fn constructor_x64_maxps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4700     let pattern0_0 = arg0;
4701     let pattern1_0 = arg1;
4702     // Rule at src/isa/x64/inst.isle line 2611.
4703     let expr0_0 = C::temp_writable_xmm(ctx);
4704     let expr1_0 = SseOpcode::Maxps;
4705     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4706     let expr3_0 = MInst::XmmRmR {
4707         op: expr1_0,
4708         src1: pattern0_0,
4709         src2: expr2_0,
4710         dst: expr0_0,
4711     };
4712     let expr4_0 = C::emit(ctx, &expr3_0);
4713     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4714     return Some(expr5_0);
4715 }
4716 
4717 // Generated as internal constructor for term x64_maxpd.
4718 pub fn constructor_x64_maxpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4719     let pattern0_0 = arg0;
4720     let pattern1_0 = arg1;
4721     // Rule at src/isa/x64/inst.isle line 2618.
4722     let expr0_0 = C::temp_writable_xmm(ctx);
4723     let expr1_0 = SseOpcode::Maxpd;
4724     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4725     let expr3_0 = MInst::XmmRmR {
4726         op: expr1_0,
4727         src1: pattern0_0,
4728         src2: expr2_0,
4729         dst: expr0_0,
4730     };
4731     let expr4_0 = C::emit(ctx, &expr3_0);
4732     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4733     return Some(expr5_0);
4734 }
4735 
4736 // Generated as internal constructor for term x64_sqrtss.
4737 pub fn constructor_x64_sqrtss<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
4738     let pattern0_0 = arg0;
4739     // Rule at src/isa/x64/inst.isle line 2626.
4740     let expr0_0 = C::temp_writable_xmm(ctx);
4741     let expr1_0 = SseOpcode::Sqrtss;
4742     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
4743     let expr3_0 = MInst::XmmUnaryRmR {
4744         op: expr1_0,
4745         src: expr2_0,
4746         dst: expr0_0,
4747     };
4748     let expr4_0 = C::emit(ctx, &expr3_0);
4749     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4750     return Some(expr5_0);
4751 }
4752 
4753 // Generated as internal constructor for term x64_sqrtsd.
4754 pub fn constructor_x64_sqrtsd<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
4755     let pattern0_0 = arg0;
4756     // Rule at src/isa/x64/inst.isle line 2633.
4757     let expr0_0 = C::temp_writable_xmm(ctx);
4758     let expr1_0 = SseOpcode::Sqrtsd;
4759     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
4760     let expr3_0 = MInst::XmmUnaryRmR {
4761         op: expr1_0,
4762         src: expr2_0,
4763         dst: expr0_0,
4764     };
4765     let expr4_0 = C::emit(ctx, &expr3_0);
4766     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4767     return Some(expr5_0);
4768 }
4769 
4770 // Generated as internal constructor for term x64_sqrtps.
4771 pub fn constructor_x64_sqrtps<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
4772     let pattern0_0 = arg0;
4773     // Rule at src/isa/x64/inst.isle line 2640.
4774     let expr0_0 = C::temp_writable_xmm(ctx);
4775     let expr1_0 = SseOpcode::Sqrtps;
4776     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
4777     let expr3_0 = MInst::XmmUnaryRmR {
4778         op: expr1_0,
4779         src: expr2_0,
4780         dst: expr0_0,
4781     };
4782     let expr4_0 = C::emit(ctx, &expr3_0);
4783     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4784     return Some(expr5_0);
4785 }
4786 
4787 // Generated as internal constructor for term x64_sqrtpd.
4788 pub fn constructor_x64_sqrtpd<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
4789     let pattern0_0 = arg0;
4790     // Rule at src/isa/x64/inst.isle line 2647.
4791     let expr0_0 = C::temp_writable_xmm(ctx);
4792     let expr1_0 = SseOpcode::Sqrtpd;
4793     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
4794     let expr3_0 = MInst::XmmUnaryRmR {
4795         op: expr1_0,
4796         src: expr2_0,
4797         dst: expr0_0,
4798     };
4799     let expr4_0 = C::emit(ctx, &expr3_0);
4800     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4801     return Some(expr5_0);
4802 }
4803 
4804 // Generated as internal constructor for term x64_pcmpeq.
4805 pub fn constructor_x64_pcmpeq<C: Context>(
4806     ctx: &mut C,
4807     arg0: Type,
4808     arg1: Xmm,
4809     arg2: &XmmMem,
4810 ) -> Option<Xmm> {
4811     let pattern0_0 = arg0;
4812     if pattern0_0 == I8X16 {
4813         let pattern2_0 = arg1;
4814         let pattern3_0 = arg2;
4815         // Rule at src/isa/x64/inst.isle line 2654.
4816         let expr0_0 = constructor_x64_pcmpeqb(ctx, pattern2_0, pattern3_0)?;
4817         return Some(expr0_0);
4818     }
4819     if pattern0_0 == I16X8 {
4820         let pattern2_0 = arg1;
4821         let pattern3_0 = arg2;
4822         // Rule at src/isa/x64/inst.isle line 2655.
4823         let expr0_0 = constructor_x64_pcmpeqw(ctx, pattern2_0, pattern3_0)?;
4824         return Some(expr0_0);
4825     }
4826     if pattern0_0 == I32X4 {
4827         let pattern2_0 = arg1;
4828         let pattern3_0 = arg2;
4829         // Rule at src/isa/x64/inst.isle line 2656.
4830         let expr0_0 = constructor_x64_pcmpeqd(ctx, pattern2_0, pattern3_0)?;
4831         return Some(expr0_0);
4832     }
4833     if pattern0_0 == I64X2 {
4834         let pattern2_0 = arg1;
4835         let pattern3_0 = arg2;
4836         // Rule at src/isa/x64/inst.isle line 2657.
4837         let expr0_0 = constructor_x64_pcmpeqq(ctx, pattern2_0, pattern3_0)?;
4838         return Some(expr0_0);
4839     }
4840     return None;
4841 }
4842 
4843 // Generated as internal constructor for term x64_pcmpeqb.
4844 pub fn constructor_x64_pcmpeqb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4845     let pattern0_0 = arg0;
4846     let pattern1_0 = arg1;
4847     // Rule at src/isa/x64/inst.isle line 2660.
4848     let expr0_0: Type = I8X16;
4849     let expr1_0 = SseOpcode::Pcmpeqb;
4850     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4851     return Some(expr2_0);
4852 }
4853 
4854 // Generated as internal constructor for term x64_pcmpeqw.
4855 pub fn constructor_x64_pcmpeqw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4856     let pattern0_0 = arg0;
4857     let pattern1_0 = arg1;
4858     // Rule at src/isa/x64/inst.isle line 2662.
4859     let expr0_0: Type = I16X8;
4860     let expr1_0 = SseOpcode::Pcmpeqw;
4861     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4862     return Some(expr2_0);
4863 }
4864 
4865 // Generated as internal constructor for term x64_pcmpeqd.
4866 pub fn constructor_x64_pcmpeqd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4867     let pattern0_0 = arg0;
4868     let pattern1_0 = arg1;
4869     // Rule at src/isa/x64/inst.isle line 2664.
4870     let expr0_0: Type = I32X4;
4871     let expr1_0 = SseOpcode::Pcmpeqd;
4872     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4873     return Some(expr2_0);
4874 }
4875 
4876 // Generated as internal constructor for term x64_pcmpeqq.
4877 pub fn constructor_x64_pcmpeqq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4878     let pattern0_0 = arg0;
4879     let pattern1_0 = arg1;
4880     // Rule at src/isa/x64/inst.isle line 2666.
4881     let expr0_0: Type = I64X2;
4882     let expr1_0 = SseOpcode::Pcmpeqq;
4883     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4884     return Some(expr2_0);
4885 }
4886 
4887 // Generated as internal constructor for term x64_pcmpgt.
4888 pub fn constructor_x64_pcmpgt<C: Context>(
4889     ctx: &mut C,
4890     arg0: Type,
4891     arg1: Xmm,
4892     arg2: &XmmMem,
4893 ) -> Option<Xmm> {
4894     let pattern0_0 = arg0;
4895     if pattern0_0 == I8X16 {
4896         let pattern2_0 = arg1;
4897         let pattern3_0 = arg2;
4898         // Rule at src/isa/x64/inst.isle line 2670.
4899         let expr0_0 = constructor_x64_pcmpgtb(ctx, pattern2_0, pattern3_0)?;
4900         return Some(expr0_0);
4901     }
4902     if pattern0_0 == I16X8 {
4903         let pattern2_0 = arg1;
4904         let pattern3_0 = arg2;
4905         // Rule at src/isa/x64/inst.isle line 2671.
4906         let expr0_0 = constructor_x64_pcmpgtw(ctx, pattern2_0, pattern3_0)?;
4907         return Some(expr0_0);
4908     }
4909     if pattern0_0 == I32X4 {
4910         let pattern2_0 = arg1;
4911         let pattern3_0 = arg2;
4912         // Rule at src/isa/x64/inst.isle line 2672.
4913         let expr0_0 = constructor_x64_pcmpgtd(ctx, pattern2_0, pattern3_0)?;
4914         return Some(expr0_0);
4915     }
4916     if pattern0_0 == I64X2 {
4917         let pattern2_0 = arg1;
4918         let pattern3_0 = arg2;
4919         // Rule at src/isa/x64/inst.isle line 2673.
4920         let expr0_0 = constructor_x64_pcmpgtq(ctx, pattern2_0, pattern3_0)?;
4921         return Some(expr0_0);
4922     }
4923     return None;
4924 }
4925 
4926 // Generated as internal constructor for term x64_pcmpgtb.
4927 pub fn constructor_x64_pcmpgtb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4928     let pattern0_0 = arg0;
4929     let pattern1_0 = arg1;
4930     // Rule at src/isa/x64/inst.isle line 2676.
4931     let expr0_0: Type = I8X16;
4932     let expr1_0 = SseOpcode::Pcmpgtb;
4933     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4934     return Some(expr2_0);
4935 }
4936 
4937 // Generated as internal constructor for term x64_pcmpgtw.
4938 pub fn constructor_x64_pcmpgtw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4939     let pattern0_0 = arg0;
4940     let pattern1_0 = arg1;
4941     // Rule at src/isa/x64/inst.isle line 2678.
4942     let expr0_0: Type = I16X8;
4943     let expr1_0 = SseOpcode::Pcmpgtw;
4944     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4945     return Some(expr2_0);
4946 }
4947 
4948 // Generated as internal constructor for term x64_pcmpgtd.
4949 pub fn constructor_x64_pcmpgtd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4950     let pattern0_0 = arg0;
4951     let pattern1_0 = arg1;
4952     // Rule at src/isa/x64/inst.isle line 2680.
4953     let expr0_0: Type = I32X4;
4954     let expr1_0 = SseOpcode::Pcmpgtd;
4955     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4956     return Some(expr2_0);
4957 }
4958 
4959 // Generated as internal constructor for term x64_pcmpgtq.
4960 pub fn constructor_x64_pcmpgtq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4961     let pattern0_0 = arg0;
4962     let pattern1_0 = arg1;
4963     // Rule at src/isa/x64/inst.isle line 2682.
4964     let expr0_0: Type = I64X2;
4965     let expr1_0 = SseOpcode::Pcmpgtq;
4966     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4967     return Some(expr2_0);
4968 }
4969 
4970 // Generated as internal constructor for term reg_to_xmm_mem.
4971 pub fn constructor_reg_to_xmm_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
4972     let pattern0_0 = arg0;
4973     // Rule at src/isa/x64/inst.isle line 2738.
4974     let expr0_0 = C::xmm_new(ctx, pattern0_0);
4975     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
4976     return Some(expr1_0);
4977 }
4978 
4979 // Generated as internal constructor for term xmm_to_reg_mem.
4980 pub fn constructor_xmm_to_reg_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
4981     let pattern0_0 = arg0;
4982     // Rule at src/isa/x64/inst.isle line 2741.
4983     let expr0_0 = C::xmm_new(ctx, pattern0_0);
4984     let expr1_0 = C::xmm_to_reg(ctx, expr0_0);
4985     let expr2_0 = RegMem::Reg { reg: expr1_0 };
4986     let expr3_0 = C::reg_mem_to_xmm_mem(ctx, &expr2_0);
4987     return Some(expr3_0);
4988 }
4989 
4990 // Generated as internal constructor for term writable_gpr_to_r_reg.
4991 pub fn constructor_writable_gpr_to_r_reg<C: Context>(
4992     ctx: &mut C,
4993     arg0: WritableGpr,
4994 ) -> Option<Reg> {
4995     let pattern0_0 = arg0;
4996     // Rule at src/isa/x64/inst.isle line 2745.
4997     let expr0_0 = C::writable_gpr_to_reg(ctx, pattern0_0);
4998     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
4999     return Some(expr1_0);
5000 }
5001 
5002 // Generated as internal constructor for term writable_gpr_to_gpr_mem.
5003 pub fn constructor_writable_gpr_to_gpr_mem<C: Context>(
5004     ctx: &mut C,
5005     arg0: WritableGpr,
5006 ) -> Option<GprMem> {
5007     let pattern0_0 = arg0;
5008     // Rule at src/isa/x64/inst.isle line 2748.
5009     let expr0_0 = C::writable_gpr_to_gpr(ctx, pattern0_0);
5010     let expr1_0 = C::gpr_to_gpr_mem(ctx, expr0_0);
5011     return Some(expr1_0);
5012 }
5013 
5014 // Generated as internal constructor for term writable_gpr_to_value_regs.
5015 pub fn constructor_writable_gpr_to_value_regs<C: Context>(
5016     ctx: &mut C,
5017     arg0: WritableGpr,
5018 ) -> Option<ValueRegs> {
5019     let pattern0_0 = arg0;
5020     // Rule at src/isa/x64/inst.isle line 2751.
5021     let expr0_0 = constructor_writable_gpr_to_r_reg(ctx, pattern0_0)?;
5022     let expr1_0 = C::value_reg(ctx, expr0_0);
5023     return Some(expr1_0);
5024 }
5025 
5026 // Generated as internal constructor for term writable_xmm_to_r_reg.
5027 pub fn constructor_writable_xmm_to_r_reg<C: Context>(
5028     ctx: &mut C,
5029     arg0: WritableXmm,
5030 ) -> Option<Reg> {
5031     let pattern0_0 = arg0;
5032     // Rule at src/isa/x64/inst.isle line 2754.
5033     let expr0_0 = C::writable_xmm_to_reg(ctx, pattern0_0);
5034     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
5035     return Some(expr1_0);
5036 }
5037 
5038 // Generated as internal constructor for term writable_xmm_to_xmm_mem.
5039 pub fn constructor_writable_xmm_to_xmm_mem<C: Context>(
5040     ctx: &mut C,
5041     arg0: WritableXmm,
5042 ) -> Option<XmmMem> {
5043     let pattern0_0 = arg0;
5044     // Rule at src/isa/x64/inst.isle line 2757.
5045     let expr0_0 = C::writable_xmm_to_xmm(ctx, pattern0_0);
5046     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
5047     return Some(expr1_0);
5048 }
5049 
5050 // Generated as internal constructor for term writable_xmm_to_value_regs.
5051 pub fn constructor_writable_xmm_to_value_regs<C: Context>(
5052     ctx: &mut C,
5053     arg0: WritableXmm,
5054 ) -> Option<ValueRegs> {
5055     let pattern0_0 = arg0;
5056     // Rule at src/isa/x64/inst.isle line 2760.
5057     let expr0_0 = constructor_writable_xmm_to_r_reg(ctx, pattern0_0)?;
5058     let expr1_0 = C::value_reg(ctx, expr0_0);
5059     return Some(expr1_0);
5060 }
5061 
5062 // Generated as internal constructor for term synthetic_amode_to_gpr_mem.
5063 pub fn constructor_synthetic_amode_to_gpr_mem<C: Context>(
5064     ctx: &mut C,
5065     arg0: &SyntheticAmode,
5066 ) -> Option<GprMem> {
5067     let pattern0_0 = arg0;
5068     // Rule at src/isa/x64/inst.isle line 2767.
5069     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5070     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
5071     return Some(expr1_0);
5072 }
5073 
5074 // Generated as internal constructor for term amode_to_gpr_mem.
5075 pub fn constructor_amode_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<GprMem> {
5076     let pattern0_0 = arg0;
5077     // Rule at src/isa/x64/inst.isle line 2765.
5078     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5079     let expr1_0 = constructor_synthetic_amode_to_gpr_mem(ctx, &expr0_0)?;
5080     return Some(expr1_0);
5081 }
5082 
5083 // Generated as internal constructor for term amode_to_xmm_mem.
5084 pub fn constructor_amode_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<XmmMem> {
5085     let pattern0_0 = arg0;
5086     // Rule at src/isa/x64/inst.isle line 2770.
5087     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5088     let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, &expr0_0)?;
5089     return Some(expr1_0);
5090 }
5091 
5092 // Generated as internal constructor for term synthetic_amode_to_xmm_mem.
5093 pub fn constructor_synthetic_amode_to_xmm_mem<C: Context>(
5094     ctx: &mut C,
5095     arg0: &SyntheticAmode,
5096 ) -> Option<XmmMem> {
5097     let pattern0_0 = arg0;
5098     // Rule at src/isa/x64/inst.isle line 2773.
5099     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5100     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
5101     return Some(expr1_0);
5102 }
5103 
5104 // Generated as internal constructor for term lower.
5105 pub fn constructor_lower<C: Context>(ctx: &mut C, arg0: Inst) -> Option<InstOutput> {
5106     let pattern0_0 = arg0;
5107     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
5108         let pattern2_0 = C::value_type(ctx, pattern1_0);
5109         if pattern2_0 == I128 {
5110             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5111                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5112                 if let &InstructionData::Unary {
5113                     opcode: ref pattern6_0,
5114                     arg: pattern6_1,
5115                 } = &pattern5_0
5116                 {
5117                     if let &Opcode::Popcnt = pattern6_0 {
5118                         // Rule at src/isa/x64/lower.isle line 1870.
5119                         let expr0_0: Type = I64;
5120                         let expr1_0 = C::put_in_regs(ctx, pattern6_1);
5121                         let expr2_0: usize = 0;
5122                         let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
5123                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5124                         let expr5_0: Type = I64;
5125                         let expr6_0 = C::put_in_regs(ctx, pattern6_1);
5126                         let expr7_0: usize = 1;
5127                         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5128                         let expr9_0 = constructor_x64_popcnt(ctx, expr5_0, expr8_0)?;
5129                         let expr10_0: Type = I64;
5130                         let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
5131                         let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
5132                         let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
5133                         let expr14_0: Type = I64;
5134                         let expr15_0: u64 = 0;
5135                         let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
5136                         let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
5137                         let expr18_0 = C::output(ctx, expr17_0);
5138                         return Some(expr18_0);
5139                     }
5140                 }
5141             }
5142         }
5143         if pattern2_0 == I8X16 {
5144             if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
5145                 if let Some(()) = C::avx512bitalg_enabled(ctx, pattern2_0) {
5146                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
5147                     if let &InstructionData::Unary {
5148                         opcode: ref pattern7_0,
5149                         arg: pattern7_1,
5150                     } = &pattern6_0
5151                     {
5152                         if let &Opcode::Popcnt = pattern7_0 {
5153                             // Rule at src/isa/x64/lower.isle line 1962.
5154                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
5155                             let expr1_0 = constructor_x64_vpopcntb(ctx, &expr0_0)?;
5156                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
5157                             return Some(expr2_0);
5158                         }
5159                     }
5160                 }
5161             }
5162         }
5163         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
5164             if let Some(()) = C::use_lzcnt(ctx, pattern2_0) {
5165                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5166                 if let &InstructionData::Unary {
5167                     opcode: ref pattern6_0,
5168                     arg: pattern6_1,
5169                 } = &pattern5_0
5170                 {
5171                     if let &Opcode::Clz = pattern6_0 {
5172                         // Rule at src/isa/x64/lower.isle line 1778.
5173                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5174                         let expr1_0 = constructor_x64_lzcnt(ctx, pattern3_0, expr0_0)?;
5175                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5176                         return Some(expr2_0);
5177                     }
5178                 }
5179             }
5180             if let Some(()) = C::use_bmi1(ctx, pattern2_0) {
5181                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5182                 if let &InstructionData::Unary {
5183                     opcode: ref pattern6_0,
5184                     arg: pattern6_1,
5185                 } = &pattern5_0
5186                 {
5187                     if let &Opcode::Ctz = pattern6_0 {
5188                         // Rule at src/isa/x64/lower.isle line 1820.
5189                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5190                         let expr1_0 = constructor_x64_tzcnt(ctx, pattern3_0, expr0_0)?;
5191                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5192                         return Some(expr2_0);
5193                     }
5194                 }
5195             }
5196             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5197                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5198                 if let &InstructionData::Unary {
5199                     opcode: ref pattern6_0,
5200                     arg: pattern6_1,
5201                 } = &pattern5_0
5202                 {
5203                     if let &Opcode::Popcnt = pattern6_0 {
5204                         // Rule at src/isa/x64/lower.isle line 1856.
5205                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5206                         let expr1_0 = constructor_x64_popcnt(ctx, pattern3_0, expr0_0)?;
5207                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5208                         return Some(expr2_0);
5209                     }
5210                 }
5211             }
5212         }
5213         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
5214             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5215                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5216                 if let &InstructionData::Unary {
5217                     opcode: ref pattern6_0,
5218                     arg: pattern6_1,
5219                 } = &pattern5_0
5220                 {
5221                     if let &Opcode::Popcnt = pattern6_0 {
5222                         // Rule at src/isa/x64/lower.isle line 1863.
5223                         let expr0_0: Type = I32;
5224                         let expr1_0: Type = I32;
5225                         let expr2_0 = ExtendKind::Zero;
5226                         let expr3_0 =
5227                             constructor_extend_to_gpr(ctx, pattern6_1, expr1_0, &expr2_0)?;
5228                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5229                         let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
5230                         return Some(expr5_0);
5231                     }
5232                 }
5233             }
5234         }
5235     }
5236     let pattern0_0 = arg0;
5237     let pattern1_0 = C::inst_data(ctx, pattern0_0);
5238     match &pattern1_0 {
5239         &InstructionData::NullAry {
5240             opcode: ref pattern2_0,
5241         } => {
5242             if let &Opcode::Debugtrap = pattern2_0 {
5243                 // Rule at src/isa/x64/lower.isle line 2248.
5244                 let expr0_0 = constructor_x64_hlt(ctx)?;
5245                 let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5246                 return Some(expr1_0);
5247             }
5248         }
5249         &InstructionData::UnaryIeee32 {
5250             opcode: ref pattern2_0,
5251             imm: pattern2_1,
5252         } => {
5253             if let &Opcode::F32const = pattern2_0 {
5254                 let pattern4_0 = C::u64_from_ieee32(ctx, pattern2_1);
5255                 // Rule at src/isa/x64/lower.isle line 46.
5256                 let expr0_0: Type = F32;
5257                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5258                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5259                 return Some(expr2_0);
5260             }
5261         }
5262         &InstructionData::UnaryIeee64 {
5263             opcode: ref pattern2_0,
5264             imm: pattern2_1,
5265         } => {
5266             if let &Opcode::F64const = pattern2_0 {
5267                 let pattern4_0 = C::u64_from_ieee64(ctx, pattern2_1);
5268                 // Rule at src/isa/x64/lower.isle line 51.
5269                 let expr0_0: Type = F64;
5270                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5271                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5272                 return Some(expr2_0);
5273             }
5274         }
5275         &InstructionData::Trap {
5276             opcode: ref pattern2_0,
5277             code: ref pattern2_1,
5278         } => {
5279             match pattern2_0 {
5280                 &Opcode::Trap => {
5281                     // Rule at src/isa/x64/lower.isle line 1432.
5282                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5283                     let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5284                     return Some(expr1_0);
5285                 }
5286                 &Opcode::ResumableTrap => {
5287                     // Rule at src/isa/x64/lower.isle line 1437.
5288                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5289                     let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5290                     return Some(expr1_0);
5291                 }
5292                 _ => {}
5293             }
5294         }
5295         &InstructionData::TernaryImm8 {
5296             opcode: ref pattern2_0,
5297             args: ref pattern2_1,
5298             imm: pattern2_2,
5299         } => {
5300             if let &Opcode::Insertlane = pattern2_0 {
5301                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5302                 let pattern5_0 = C::value_type(ctx, pattern4_0);
5303                 let pattern6_0 = C::u8_from_uimm8(ctx, pattern2_2);
5304                 // Rule at src/isa/x64/lower.isle line 1302.
5305                 let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5306                 let expr1_0 = C::put_in_reg_mem(ctx, pattern4_1);
5307                 let expr2_0 =
5308                     constructor_vec_insert_lane(ctx, pattern5_0, expr0_0, &expr1_0, pattern6_0)?;
5309                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5310                 return Some(expr3_0);
5311             }
5312         }
5313         &InstructionData::FloatCompare {
5314             opcode: ref pattern2_0,
5315             args: ref pattern2_1,
5316             cond: ref pattern2_2,
5317         } => {
5318             if let &Opcode::Fcmp = pattern2_0 {
5319                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5320                 let pattern5_0 = C::value_type(ctx, pattern4_0);
5321                 if let Some(pattern6_0) = C::ty_scalar_float(ctx, pattern5_0) {
5322                     match pattern2_2 {
5323                         &FloatCC::Equal => {
5324                             // Rule at src/isa/x64/lower.isle line 1569.
5325                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5326                             let expr1_0 = CC::NP;
5327                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5328                             let expr3_0 = CC::Z;
5329                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
5330                             let expr5_0 =
5331                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
5332                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
5333                             let expr7_0: usize = 0;
5334                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5335                             let expr9_0: usize = 1;
5336                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
5337                             let expr11_0: Type = I32;
5338                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
5339                             let expr13_0 = constructor_x64_and(ctx, expr11_0, expr8_0, &expr12_0)?;
5340                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
5341                             return Some(expr14_0);
5342                         }
5343                         &FloatCC::GreaterThan => {
5344                             // Rule at src/isa/x64/lower.isle line 1597.
5345                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5346                             let expr1_0 = CC::NBE;
5347                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5348                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5349                             let expr4_0 = C::output(ctx, expr3_0);
5350                             return Some(expr4_0);
5351                         }
5352                         &FloatCC::GreaterThanOrEqual => {
5353                             // Rule at src/isa/x64/lower.isle line 1599.
5354                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5355                             let expr1_0 = CC::NB;
5356                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5357                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5358                             let expr4_0 = C::output(ctx, expr3_0);
5359                             return Some(expr4_0);
5360                         }
5361                         &FloatCC::LessThan => {
5362                             // Rule at src/isa/x64/lower.isle line 1609.
5363                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5364                             let expr1_0 = CC::NBE;
5365                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5366                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5367                             let expr4_0 = C::output(ctx, expr3_0);
5368                             return Some(expr4_0);
5369                         }
5370                         &FloatCC::LessThanOrEqual => {
5371                             // Rule at src/isa/x64/lower.isle line 1612.
5372                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5373                             let expr1_0 = CC::NB;
5374                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5375                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5376                             let expr4_0 = C::output(ctx, expr3_0);
5377                             return Some(expr4_0);
5378                         }
5379                         &FloatCC::NotEqual => {
5380                             // Rule at src/isa/x64/lower.isle line 1578.
5381                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5382                             let expr1_0 = CC::P;
5383                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5384                             let expr3_0 = CC::NZ;
5385                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
5386                             let expr5_0 =
5387                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
5388                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
5389                             let expr7_0: usize = 0;
5390                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5391                             let expr9_0: usize = 1;
5392                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
5393                             let expr11_0: Type = I32;
5394                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
5395                             let expr13_0 = constructor_x64_or(ctx, expr11_0, expr8_0, &expr12_0)?;
5396                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
5397                             return Some(expr14_0);
5398                         }
5399                         &FloatCC::Ordered => {
5400                             // Rule at src/isa/x64/lower.isle line 1589.
5401                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5402                             let expr1_0 = CC::NP;
5403                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5404                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5405                             let expr4_0 = C::output(ctx, expr3_0);
5406                             return Some(expr4_0);
5407                         }
5408                         &FloatCC::OrderedNotEqual => {
5409                             // Rule at src/isa/x64/lower.isle line 1593.
5410                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5411                             let expr1_0 = CC::NZ;
5412                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5413                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5414                             let expr4_0 = C::output(ctx, expr3_0);
5415                             return Some(expr4_0);
5416                         }
5417                         &FloatCC::Unordered => {
5418                             // Rule at src/isa/x64/lower.isle line 1591.
5419                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5420                             let expr1_0 = CC::P;
5421                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5422                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5423                             let expr4_0 = C::output(ctx, expr3_0);
5424                             return Some(expr4_0);
5425                         }
5426                         &FloatCC::UnorderedOrEqual => {
5427                             // Rule at src/isa/x64/lower.isle line 1595.
5428                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5429                             let expr1_0 = CC::Z;
5430                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5431                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5432                             let expr4_0 = C::output(ctx, expr3_0);
5433                             return Some(expr4_0);
5434                         }
5435                         &FloatCC::UnorderedOrGreaterThan => {
5436                             // Rule at src/isa/x64/lower.isle line 1615.
5437                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5438                             let expr1_0 = CC::B;
5439                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5440                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5441                             let expr4_0 = C::output(ctx, expr3_0);
5442                             return Some(expr4_0);
5443                         }
5444                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
5445                             // Rule at src/isa/x64/lower.isle line 1618.
5446                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5447                             let expr1_0 = CC::BE;
5448                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5449                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5450                             let expr4_0 = C::output(ctx, expr3_0);
5451                             return Some(expr4_0);
5452                         }
5453                         &FloatCC::UnorderedOrLessThan => {
5454                             // Rule at src/isa/x64/lower.isle line 1601.
5455                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5456                             let expr1_0 = CC::B;
5457                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5458                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5459                             let expr4_0 = C::output(ctx, expr3_0);
5460                             return Some(expr4_0);
5461                         }
5462                         &FloatCC::UnorderedOrLessThanOrEqual => {
5463                             // Rule at src/isa/x64/lower.isle line 1603.
5464                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5465                             let expr1_0 = CC::BE;
5466                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5467                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5468                             let expr4_0 = C::output(ctx, expr3_0);
5469                             return Some(expr4_0);
5470                         }
5471                         _ => {}
5472                     }
5473                 }
5474                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
5475                     match pattern2_2 {
5476                         &FloatCC::Equal => {
5477                             // Rule at src/isa/x64/lower.isle line 1626.
5478                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5479                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5480                             let expr2_0 = FcmpImm::Equal;
5481                             let expr3_0 =
5482                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5483                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5484                             return Some(expr4_0);
5485                         }
5486                         &FloatCC::GreaterThan => {
5487                             // Rule at src/isa/x64/lower.isle line 1646.
5488                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5489                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5490                             let expr2_0 = FcmpImm::LessThan;
5491                             let expr3_0 =
5492                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5493                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5494                             return Some(expr4_0);
5495                         }
5496                         &FloatCC::GreaterThanOrEqual => {
5497                             // Rule at src/isa/x64/lower.isle line 1648.
5498                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5499                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5500                             let expr2_0 = FcmpImm::LessThanOrEqual;
5501                             let expr3_0 =
5502                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5503                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5504                             return Some(expr4_0);
5505                         }
5506                         &FloatCC::LessThan => {
5507                             // Rule at src/isa/x64/lower.isle line 1630.
5508                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5509                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5510                             let expr2_0 = FcmpImm::LessThan;
5511                             let expr3_0 =
5512                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5513                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5514                             return Some(expr4_0);
5515                         }
5516                         &FloatCC::LessThanOrEqual => {
5517                             // Rule at src/isa/x64/lower.isle line 1632.
5518                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5519                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5520                             let expr2_0 = FcmpImm::LessThanOrEqual;
5521                             let expr3_0 =
5522                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5523                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5524                             return Some(expr4_0);
5525                         }
5526                         &FloatCC::NotEqual => {
5527                             // Rule at src/isa/x64/lower.isle line 1628.
5528                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5529                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5530                             let expr2_0 = FcmpImm::NotEqual;
5531                             let expr3_0 =
5532                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5533                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5534                             return Some(expr4_0);
5535                         }
5536                         &FloatCC::Ordered => {
5537                             // Rule at src/isa/x64/lower.isle line 1634.
5538                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5539                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5540                             let expr2_0 = FcmpImm::Ordered;
5541                             let expr3_0 =
5542                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5543                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5544                             return Some(expr4_0);
5545                         }
5546                         &FloatCC::Unordered => {
5547                             // Rule at src/isa/x64/lower.isle line 1636.
5548                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5549                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5550                             let expr2_0 = FcmpImm::Unordered;
5551                             let expr3_0 =
5552                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5553                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5554                             return Some(expr4_0);
5555                         }
5556                         &FloatCC::UnorderedOrGreaterThan => {
5557                             // Rule at src/isa/x64/lower.isle line 1638.
5558                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5559                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5560                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
5561                             let expr3_0 =
5562                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5563                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5564                             return Some(expr4_0);
5565                         }
5566                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
5567                             // Rule at src/isa/x64/lower.isle line 1640.
5568                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5569                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5570                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
5571                             let expr3_0 =
5572                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5573                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5574                             return Some(expr4_0);
5575                         }
5576                         &FloatCC::UnorderedOrLessThan => {
5577                             // Rule at src/isa/x64/lower.isle line 1650.
5578                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5579                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5580                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
5581                             let expr3_0 =
5582                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5583                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5584                             return Some(expr4_0);
5585                         }
5586                         &FloatCC::UnorderedOrLessThanOrEqual => {
5587                             // Rule at src/isa/x64/lower.isle line 1652.
5588                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5589                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5590                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
5591                             let expr3_0 =
5592                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5593                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5594                             return Some(expr4_0);
5595                         }
5596                         _ => {}
5597                     }
5598                 }
5599             }
5600         }
5601         &InstructionData::IntCompare {
5602             opcode: ref pattern2_0,
5603             args: ref pattern2_1,
5604             cond: ref pattern2_2,
5605         } => {
5606             if let &Opcode::Icmp = pattern2_0 {
5607                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5608                 let pattern5_0 = C::value_type(ctx, pattern4_0);
5609                 if pattern5_0 == I128 {
5610                     match pattern2_2 {
5611                         &IntCC::Equal => {
5612                             // Rule at src/isa/x64/lower.isle line 1520.
5613                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
5614                             let expr1_0: usize = 0;
5615                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5616                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
5617                             let expr4_0: usize = 1;
5618                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
5619                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
5620                             let expr7_0: usize = 0;
5621                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5622                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
5623                             let expr10_0: usize = 1;
5624                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
5625                             let expr12_0 = OperandSize::Size64;
5626                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
5627                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
5628                             let expr15_0 = CC::Z;
5629                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
5630                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
5631                             let expr18_0 = OperandSize::Size64;
5632                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
5633                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
5634                             let expr21_0 = CC::Z;
5635                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
5636                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
5637                             let expr24_0: Type = I64;
5638                             let expr25_0 = C::gpr_new(ctx, expr17_0);
5639                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
5640                             let expr27_0 = constructor_x64_and(ctx, expr24_0, expr25_0, &expr26_0)?;
5641                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
5642                             let expr29_0 = OperandSize::Size64;
5643                             let expr30_0: u32 = 1;
5644                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
5645                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
5646                             let expr33_0 = C::gpr_new(ctx, expr28_0);
5647                             let expr34_0 =
5648                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
5649                             let expr35_0 = CC::NZ;
5650                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
5651                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
5652                             let expr38_0 = C::output(ctx, expr37_0);
5653                             return Some(expr38_0);
5654                         }
5655                         &IntCC::NotEqual => {
5656                             // Rule at src/isa/x64/lower.isle line 1539.
5657                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
5658                             let expr1_0: usize = 0;
5659                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5660                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
5661                             let expr4_0: usize = 1;
5662                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
5663                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
5664                             let expr7_0: usize = 0;
5665                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5666                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
5667                             let expr10_0: usize = 1;
5668                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
5669                             let expr12_0 = OperandSize::Size64;
5670                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
5671                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
5672                             let expr15_0 = CC::NZ;
5673                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
5674                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
5675                             let expr18_0 = OperandSize::Size64;
5676                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
5677                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
5678                             let expr21_0 = CC::NZ;
5679                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
5680                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
5681                             let expr24_0: Type = I64;
5682                             let expr25_0 = C::gpr_new(ctx, expr17_0);
5683                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
5684                             let expr27_0 = constructor_x64_or(ctx, expr24_0, expr25_0, &expr26_0)?;
5685                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
5686                             let expr29_0 = OperandSize::Size64;
5687                             let expr30_0: u32 = 1;
5688                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
5689                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
5690                             let expr33_0 = C::gpr_new(ctx, expr28_0);
5691                             let expr34_0 =
5692                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
5693                             let expr35_0 = CC::NZ;
5694                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
5695                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
5696                             let expr38_0 = C::output(ctx, expr37_0);
5697                             return Some(expr38_0);
5698                         }
5699                         _ => {}
5700                     }
5701                 }
5702                 if pattern5_0 == I64X2 {
5703                     match pattern2_2 {
5704                         &IntCC::SignedGreaterThanOrEqual => {
5705                             // Rule at src/isa/x64/lower.isle line 1505.
5706                             let expr0_0: Type = I64X2;
5707                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5708                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5709                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
5710                             let expr4_0: Type = I64X2;
5711                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
5712                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
5713                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
5714                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
5715                             return Some(expr8_0);
5716                         }
5717                         &IntCC::SignedLessThanOrEqual => {
5718                             // Rule at src/isa/x64/lower.isle line 1509.
5719                             let expr0_0: Type = I64X2;
5720                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5721                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5722                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
5723                             let expr4_0: Type = I64X2;
5724                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
5725                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
5726                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
5727                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
5728                             return Some(expr8_0);
5729                         }
5730                         _ => {}
5731                     }
5732                 }
5733                 if let Some(pattern6_0) = C::fits_in_64(ctx, pattern5_0) {
5734                     // Rule at src/isa/x64/lower.isle line 1445.
5735                     let expr0_0 = C::raw_operand_size_of_type(ctx, pattern6_0);
5736                     let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern4_1)?;
5737                     let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
5738                     let expr3_0 = constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?;
5739                     let expr4_0 = C::intcc_to_cc(ctx, pattern2_2);
5740                     let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
5741                     let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
5742                     let expr7_0 = C::output(ctx, expr6_0);
5743                     return Some(expr7_0);
5744                 }
5745                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
5746                     match pattern2_2 {
5747                         &IntCC::Equal => {
5748                             // Rule at src/isa/x64/lower.isle line 1454.
5749                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5750                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5751                             let expr2_0 =
5752                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
5753                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5754                             return Some(expr3_0);
5755                         }
5756                         &IntCC::NotEqual => {
5757                             // Rule at src/isa/x64/lower.isle line 1458.
5758                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5759                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5760                             let expr2_0 =
5761                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
5762                             let expr3_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
5763                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
5764                             let expr5_0 = constructor_x64_pxor(ctx, expr2_0, &expr4_0)?;
5765                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5766                             return Some(expr6_0);
5767                         }
5768                         &IntCC::SignedGreaterThan => {
5769                             // Rule at src/isa/x64/lower.isle line 1465.
5770                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5771                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5772                             let expr2_0 =
5773                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
5774                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5775                             return Some(expr3_0);
5776                         }
5777                         &IntCC::SignedGreaterThanOrEqual => {
5778                             // Rule at src/isa/x64/lower.isle line 1490.
5779                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5780                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5781                             let expr2_0 =
5782                                 constructor_x64_pmaxs(ctx, pattern6_0, expr0_0, &expr1_0)?;
5783                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5784                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5785                             let expr5_0 =
5786                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5787                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5788                             return Some(expr6_0);
5789                         }
5790                         &IntCC::SignedLessThan => {
5791                             // Rule at src/isa/x64/lower.isle line 1467.
5792                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5793                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5794                             let expr2_0 =
5795                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
5796                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5797                             return Some(expr3_0);
5798                         }
5799                         &IntCC::SignedLessThanOrEqual => {
5800                             // Rule at src/isa/x64/lower.isle line 1493.
5801                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5802                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5803                             let expr2_0 =
5804                                 constructor_x64_pmins(ctx, pattern6_0, expr0_0, &expr1_0)?;
5805                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5806                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5807                             let expr5_0 =
5808                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5809                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5810                             return Some(expr6_0);
5811                         }
5812                         &IntCC::UnsignedGreaterThan => {
5813                             // Rule at src/isa/x64/lower.isle line 1469.
5814                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5815                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5816                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5817                             let expr3_0 =
5818                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr2_0)?;
5819                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5820                             let expr5_0 =
5821                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5822                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
5823                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
5824                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
5825                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
5826                             return Some(expr9_0);
5827                         }
5828                         &IntCC::UnsignedGreaterThanOrEqual => {
5829                             // Rule at src/isa/x64/lower.isle line 1496.
5830                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5831                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5832                             let expr2_0 =
5833                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr1_0)?;
5834                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5835                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5836                             let expr5_0 =
5837                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5838                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5839                             return Some(expr6_0);
5840                         }
5841                         &IntCC::UnsignedLessThan => {
5842                             // Rule at src/isa/x64/lower.isle line 1479.
5843                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5844                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5845                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5846                             let expr3_0 =
5847                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr2_0)?;
5848                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5849                             let expr5_0 =
5850                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5851                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
5852                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
5853                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
5854                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
5855                             return Some(expr9_0);
5856                         }
5857                         &IntCC::UnsignedLessThanOrEqual => {
5858                             // Rule at src/isa/x64/lower.isle line 1499.
5859                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5860                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5861                             let expr2_0 =
5862                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr1_0)?;
5863                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5864                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5865                             let expr5_0 =
5866                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5867                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5868                             return Some(expr6_0);
5869                         }
5870                         _ => {}
5871                     }
5872                 }
5873             }
5874         }
5875         &InstructionData::Unary {
5876             opcode: ref pattern2_0,
5877             arg: pattern2_1,
5878         } => {
5879             match pattern2_0 {
5880                 &Opcode::IsNull => {
5881                     let pattern4_0 = C::value_type(ctx, pattern2_1);
5882                     if pattern4_0 == R64 {
5883                         // Rule at src/isa/x64/lower.isle line 2091.
5884                         let expr0_0 = OperandSize::Size64;
5885                         let expr1_0: u32 = 0;
5886                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
5887                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
5888                         let expr4_0 = CC::Z;
5889                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
5890                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
5891                         let expr7_0 = C::output(ctx, expr6_0);
5892                         return Some(expr7_0);
5893                     }
5894                 }
5895                 &Opcode::IsInvalid => {
5896                     let pattern4_0 = C::value_type(ctx, pattern2_1);
5897                     if pattern4_0 == R64 {
5898                         // Rule at src/isa/x64/lower.isle line 2099.
5899                         let expr0_0 = OperandSize::Size64;
5900                         let expr1_0: u32 = 4294967295;
5901                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
5902                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
5903                         let expr4_0 = CC::Z;
5904                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
5905                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
5906                         let expr7_0 = C::output(ctx, expr6_0);
5907                         return Some(expr7_0);
5908                     }
5909                 }
5910                 _ => {}
5911             }
5912         }
5913         _ => {}
5914     }
5915     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
5916         let pattern2_0 = C::value_type(ctx, pattern1_0);
5917         if pattern2_0 == B128 {
5918             let pattern4_0 = C::inst_data(ctx, pattern0_0);
5919             match &pattern4_0 {
5920                 &InstructionData::UnaryBool {
5921                     opcode: ref pattern5_0,
5922                     imm: pattern5_1,
5923                 } => {
5924                     if let &Opcode::Bconst = pattern5_0 {
5925                         if pattern5_1 == true {
5926                             // Rule at src/isa/x64/lower.isle line 39.
5927                             let expr0_0: Type = B64;
5928                             let expr1_0: u64 = 1;
5929                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
5930                             let expr3_0: Type = B64;
5931                             let expr4_0: u64 = 0;
5932                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
5933                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
5934                             let expr7_0 = C::output(ctx, expr6_0);
5935                             return Some(expr7_0);
5936                         }
5937                         if pattern5_1 == false {
5938                             // Rule at src/isa/x64/lower.isle line 34.
5939                             let expr0_0: Type = B64;
5940                             let expr1_0: u64 = 0;
5941                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
5942                             let expr3_0: Type = B64;
5943                             let expr4_0: u64 = 0;
5944                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
5945                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
5946                             let expr7_0 = C::output(ctx, expr6_0);
5947                             return Some(expr7_0);
5948                         }
5949                     }
5950                 }
5951                 &InstructionData::Binary {
5952                     opcode: ref pattern5_0,
5953                     args: ref pattern5_1,
5954                 } => {
5955                     match pattern5_0 {
5956                         &Opcode::Band => {
5957                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
5958                             // Rule at src/isa/x64/lower.isle line 344.
5959                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
5960                             let expr1_0: usize = 0;
5961                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5962                             let expr3_0: usize = 1;
5963                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
5964                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
5965                             let expr6_0: Type = I64;
5966                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
5967                             let expr8_0 = constructor_x64_and(ctx, expr6_0, expr2_0, &expr7_0)?;
5968                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
5969                             let expr10_0 = C::output(ctx, expr9_0);
5970                             return Some(expr10_0);
5971                         }
5972                         &Opcode::Bor => {
5973                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
5974                             // Rule at src/isa/x64/lower.isle line 410.
5975                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
5976                             let expr1_0: usize = 0;
5977                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5978                             let expr3_0: usize = 1;
5979                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
5980                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
5981                             let expr6_0: Type = I64;
5982                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
5983                             let expr8_0 = constructor_x64_or(ctx, expr6_0, expr2_0, &expr7_0)?;
5984                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
5985                             let expr10_0 = C::output(ctx, expr9_0);
5986                             return Some(expr10_0);
5987                         }
5988                         &Opcode::Bxor => {
5989                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
5990                             // Rule at src/isa/x64/lower.isle line 468.
5991                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
5992                             let expr1_0: usize = 0;
5993                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5994                             let expr3_0: usize = 1;
5995                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
5996                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
5997                             let expr6_0: Type = I64;
5998                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
5999                             let expr8_0 = constructor_x64_xor(ctx, expr6_0, expr2_0, &expr7_0)?;
6000                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
6001                             let expr10_0 = C::output(ctx, expr9_0);
6002                             return Some(expr10_0);
6003                         }
6004                         _ => {}
6005                     }
6006                 }
6007                 &InstructionData::Unary {
6008                     opcode: ref pattern5_0,
6009                     arg: pattern5_1,
6010                 } => {
6011                     if let &Opcode::Bnot = pattern5_0 {
6012                         // Rule at src/isa/x64/lower.isle line 1269.
6013                         let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
6014                         let expr1_0 = C::output(ctx, expr0_0);
6015                         return Some(expr1_0);
6016                     }
6017                 }
6018                 _ => {}
6019             }
6020         }
6021         if pattern2_0 == I8 {
6022             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6023             if let &InstructionData::Unary {
6024                 opcode: ref pattern5_0,
6025                 arg: pattern5_1,
6026             } = &pattern4_0
6027             {
6028                 if let &Opcode::Bitrev = pattern5_0 {
6029                     // Rule at src/isa/x64/lower.isle line 2013.
6030                     let expr0_0: Type = I32;
6031                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6032                     let expr2_0 = constructor_do_bitrev8(ctx, expr0_0, expr1_0)?;
6033                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6034                     return Some(expr3_0);
6035                 }
6036             }
6037         }
6038         if pattern2_0 == I16 {
6039             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6040             if let &InstructionData::Unary {
6041                 opcode: ref pattern5_0,
6042                 arg: pattern5_1,
6043             } = &pattern4_0
6044             {
6045                 if let &Opcode::Bitrev = pattern5_0 {
6046                     // Rule at src/isa/x64/lower.isle line 2016.
6047                     let expr0_0: Type = I32;
6048                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6049                     let expr2_0 = constructor_do_bitrev16(ctx, expr0_0, expr1_0)?;
6050                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6051                     return Some(expr3_0);
6052                 }
6053             }
6054         }
6055         if pattern2_0 == I32 {
6056             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6057             if let &InstructionData::Unary {
6058                 opcode: ref pattern5_0,
6059                 arg: pattern5_1,
6060             } = &pattern4_0
6061             {
6062                 if let &Opcode::Bitrev = pattern5_0 {
6063                     // Rule at src/isa/x64/lower.isle line 2019.
6064                     let expr0_0: Type = I32;
6065                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6066                     let expr2_0 = constructor_do_bitrev32(ctx, expr0_0, expr1_0)?;
6067                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6068                     return Some(expr3_0);
6069                 }
6070             }
6071         }
6072         if pattern2_0 == I64 {
6073             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6074             if let &InstructionData::Unary {
6075                 opcode: ref pattern5_0,
6076                 arg: pattern5_1,
6077             } = &pattern4_0
6078             {
6079                 match pattern5_0 {
6080                     &Opcode::Bitrev => {
6081                         // Rule at src/isa/x64/lower.isle line 2022.
6082                         let expr0_0: Type = I64;
6083                         let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6084                         let expr2_0 = constructor_do_bitrev64(ctx, expr0_0, expr1_0)?;
6085                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6086                         return Some(expr3_0);
6087                     }
6088                     &Opcode::Uextend => {
6089                         if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
6090                             if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
6091                                 let pattern9_0 = C::value_type(ctx, pattern8_0);
6092                                 if pattern9_0 == I32 {
6093                                     let pattern11_0 = C::inst_data(ctx, pattern7_0);
6094                                     match &pattern11_0 {
6095                                         &InstructionData::Binary {
6096                                             opcode: ref pattern12_0,
6097                                             args: ref pattern12_1,
6098                                         } => {
6099                                             match pattern12_0 {
6100                                                 &Opcode::Iadd => {
6101                                                     let (pattern14_0, pattern14_1) =
6102                                                         C::unpack_value_array_2(ctx, pattern12_1);
6103                                                     // Rule at src/isa/x64/lower.isle line 2138.
6104                                                     let expr0_0 =
6105                                                         constructor_output_value(ctx, pattern5_1)?;
6106                                                     return Some(expr0_0);
6107                                                 }
6108                                                 &Opcode::Isub => {
6109                                                     let (pattern14_0, pattern14_1) =
6110                                                         C::unpack_value_array_2(ctx, pattern12_1);
6111                                                     // Rule at src/isa/x64/lower.isle line 2144.
6112                                                     let expr0_0 =
6113                                                         constructor_output_value(ctx, pattern5_1)?;
6114                                                     return Some(expr0_0);
6115                                                 }
6116                                                 &Opcode::Imul => {
6117                                                     let (pattern14_0, pattern14_1) =
6118                                                         C::unpack_value_array_2(ctx, pattern12_1);
6119                                                     // Rule at src/isa/x64/lower.isle line 2147.
6120                                                     let expr0_0 =
6121                                                         constructor_output_value(ctx, pattern5_1)?;
6122                                                     return Some(expr0_0);
6123                                                 }
6124                                                 &Opcode::IaddIfcout => {
6125                                                     let (pattern14_0, pattern14_1) =
6126                                                         C::unpack_value_array_2(ctx, pattern12_1);
6127                                                     // Rule at src/isa/x64/lower.isle line 2141.
6128                                                     let expr0_0 =
6129                                                         constructor_output_value(ctx, pattern5_1)?;
6130                                                     return Some(expr0_0);
6131                                                 }
6132                                                 &Opcode::Band => {
6133                                                     let (pattern14_0, pattern14_1) =
6134                                                         C::unpack_value_array_2(ctx, pattern12_1);
6135                                                     // Rule at src/isa/x64/lower.isle line 2150.
6136                                                     let expr0_0 =
6137                                                         constructor_output_value(ctx, pattern5_1)?;
6138                                                     return Some(expr0_0);
6139                                                 }
6140                                                 &Opcode::Bor => {
6141                                                     let (pattern14_0, pattern14_1) =
6142                                                         C::unpack_value_array_2(ctx, pattern12_1);
6143                                                     // Rule at src/isa/x64/lower.isle line 2153.
6144                                                     let expr0_0 =
6145                                                         constructor_output_value(ctx, pattern5_1)?;
6146                                                     return Some(expr0_0);
6147                                                 }
6148                                                 &Opcode::Bxor => {
6149                                                     let (pattern14_0, pattern14_1) =
6150                                                         C::unpack_value_array_2(ctx, pattern12_1);
6151                                                     // Rule at src/isa/x64/lower.isle line 2156.
6152                                                     let expr0_0 =
6153                                                         constructor_output_value(ctx, pattern5_1)?;
6154                                                     return Some(expr0_0);
6155                                                 }
6156                                                 &Opcode::Ishl => {
6157                                                     let (pattern14_0, pattern14_1) =
6158                                                         C::unpack_value_array_2(ctx, pattern12_1);
6159                                                     // Rule at src/isa/x64/lower.isle line 2159.
6160                                                     let expr0_0 =
6161                                                         constructor_output_value(ctx, pattern5_1)?;
6162                                                     return Some(expr0_0);
6163                                                 }
6164                                                 &Opcode::Ushr => {
6165                                                     let (pattern14_0, pattern14_1) =
6166                                                         C::unpack_value_array_2(ctx, pattern12_1);
6167                                                     // Rule at src/isa/x64/lower.isle line 2162.
6168                                                     let expr0_0 =
6169                                                         constructor_output_value(ctx, pattern5_1)?;
6170                                                     return Some(expr0_0);
6171                                                 }
6172                                                 _ => {}
6173                                             }
6174                                         }
6175                                         &InstructionData::Load {
6176                                             opcode: ref pattern12_0,
6177                                             arg: pattern12_1,
6178                                             flags: pattern12_2,
6179                                             offset: pattern12_3,
6180                                         } => {
6181                                             if let &Opcode::Uload32 = pattern12_0 {
6182                                                 // Rule at src/isa/x64/lower.isle line 2165.
6183                                                 let expr0_0 =
6184                                                     constructor_output_value(ctx, pattern5_1)?;
6185                                                 return Some(expr0_0);
6186                                             }
6187                                         }
6188                                         _ => {}
6189                                     }
6190                                 }
6191                             }
6192                         }
6193                         let pattern7_0 = C::value_type(ctx, pattern5_1);
6194                         if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
6195                             // Rule at src/isa/x64/lower.isle line 2120.
6196                             let expr0_0: Type = I64;
6197                             let expr1_0 = ExtendKind::Zero;
6198                             let expr2_0 =
6199                                 constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
6200                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6201                             return Some(expr3_0);
6202                         }
6203                     }
6204                     _ => {}
6205                 }
6206             }
6207         }
6208         if pattern2_0 == I128 {
6209             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6210             match &pattern4_0 {
6211                 &InstructionData::UnaryImm {
6212                     opcode: ref pattern5_0,
6213                     imm: pattern5_1,
6214                 } => {
6215                     if let &Opcode::Iconst = pattern5_0 {
6216                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
6217                         // Rule at src/isa/x64/lower.isle line 15.
6218                         let expr0_0: Type = I64;
6219                         let expr1_0 = constructor_imm(ctx, expr0_0, pattern7_0)?;
6220                         let expr2_0: Type = I64;
6221                         let expr3_0: u64 = 0;
6222                         let expr4_0 = constructor_imm(ctx, expr2_0, expr3_0)?;
6223                         let expr5_0 = C::value_regs(ctx, expr1_0, expr4_0);
6224                         let expr6_0 = C::output(ctx, expr5_0);
6225                         return Some(expr6_0);
6226                     }
6227                 }
6228                 &InstructionData::Binary {
6229                     opcode: ref pattern5_0,
6230                     args: ref pattern5_1,
6231                 } => {
6232                     match pattern5_0 {
6233                         &Opcode::Iadd => {
6234                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6235                             // Rule at src/isa/x64/lower.isle line 111.
6236                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6237                             let expr1_0: usize = 0;
6238                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6239                             let expr3_0: usize = 1;
6240                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6241                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6242                             let expr6_0: usize = 0;
6243                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6244                             let expr8_0: usize = 1;
6245                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6246                             let expr10_0: Type = I64;
6247                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6248                             let expr12_0 = constructor_x64_add_with_flags_paired(
6249                                 ctx, expr10_0, expr2_0, &expr11_0,
6250                             )?;
6251                             let expr13_0: Type = I64;
6252                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6253                             let expr15_0 =
6254                                 constructor_x64_adc_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
6255                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
6256                             let expr17_0 = C::output(ctx, expr16_0);
6257                             return Some(expr17_0);
6258                         }
6259                         &Opcode::Isub => {
6260                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6261                             // Rule at src/isa/x64/lower.isle line 257.
6262                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6263                             let expr1_0: usize = 0;
6264                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6265                             let expr3_0: usize = 1;
6266                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6267                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6268                             let expr6_0: usize = 0;
6269                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6270                             let expr8_0: usize = 1;
6271                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6272                             let expr10_0: Type = I64;
6273                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6274                             let expr12_0 = constructor_x64_sub_with_flags_paired(
6275                                 ctx, expr10_0, expr2_0, &expr11_0,
6276                             )?;
6277                             let expr13_0: Type = I64;
6278                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6279                             let expr15_0 =
6280                                 constructor_x64_sbb_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
6281                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
6282                             let expr17_0 = C::output(ctx, expr16_0);
6283                             return Some(expr17_0);
6284                         }
6285                         &Opcode::Imul => {
6286                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6287                             // Rule at src/isa/x64/lower.isle line 957.
6288                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6289                             let expr1_0: usize = 0;
6290                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6291                             let expr3_0: usize = 1;
6292                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6293                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6294                             let expr6_0: usize = 0;
6295                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6296                             let expr8_0: usize = 1;
6297                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6298                             let expr10_0: Type = I64;
6299                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6300                             let expr12_0 = constructor_x64_mul(ctx, expr10_0, expr2_0, &expr11_0)?;
6301                             let expr13_0: Type = I64;
6302                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6303                             let expr15_0 = constructor_x64_mul(ctx, expr13_0, expr4_0, &expr14_0)?;
6304                             let expr16_0: Type = I64;
6305                             let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr15_0);
6306                             let expr18_0 = constructor_x64_add(ctx, expr16_0, expr12_0, &expr17_0)?;
6307                             let expr19_0: Type = I64;
6308                             let expr20_0 = C::gpr_to_gpr_mem(ctx, expr7_0);
6309                             let expr21_0 = constructor_mulhi_u(ctx, expr19_0, expr2_0, &expr20_0)?;
6310                             let expr22_0: usize = 0;
6311                             let expr23_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr22_0)?;
6312                             let expr24_0: usize = 1;
6313                             let expr25_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr24_0)?;
6314                             let expr26_0: Type = I64;
6315                             let expr27_0 = C::gpr_to_gpr_mem_imm(ctx, expr25_0);
6316                             let expr28_0 = constructor_x64_add(ctx, expr26_0, expr18_0, &expr27_0)?;
6317                             let expr29_0 = constructor_value_gprs(ctx, expr23_0, expr28_0)?;
6318                             let expr30_0 = C::output(ctx, expr29_0);
6319                             return Some(expr30_0);
6320                         }
6321                         &Opcode::Band => {
6322                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6323                             // Rule at src/isa/x64/lower.isle line 334.
6324                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6325                             let expr1_0: usize = 0;
6326                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6327                             let expr3_0: usize = 1;
6328                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6329                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6330                             let expr6_0: usize = 0;
6331                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6332                             let expr8_0: usize = 1;
6333                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6334                             let expr10_0: Type = I64;
6335                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6336                             let expr12_0 = constructor_x64_and(ctx, expr10_0, expr2_0, &expr11_0)?;
6337                             let expr13_0: Type = I64;
6338                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6339                             let expr15_0 = constructor_x64_and(ctx, expr13_0, expr4_0, &expr14_0)?;
6340                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
6341                             let expr17_0 = C::output(ctx, expr16_0);
6342                             return Some(expr17_0);
6343                         }
6344                         &Opcode::Bor => {
6345                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6346                             // Rule at src/isa/x64/lower.isle line 407.
6347                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6348                             let expr1_0 = C::put_in_regs(ctx, pattern7_1);
6349                             let expr2_0 = constructor_or_i128(ctx, expr0_0, expr1_0)?;
6350                             let expr3_0 = C::output(ctx, expr2_0);
6351                             return Some(expr3_0);
6352                         }
6353                         &Opcode::Bxor => {
6354                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6355                             // Rule at src/isa/x64/lower.isle line 458.
6356                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6357                             let expr1_0: usize = 0;
6358                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6359                             let expr3_0: usize = 1;
6360                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6361                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6362                             let expr6_0: usize = 0;
6363                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6364                             let expr8_0: usize = 1;
6365                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6366                             let expr10_0: Type = I64;
6367                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6368                             let expr12_0 = constructor_x64_xor(ctx, expr10_0, expr2_0, &expr11_0)?;
6369                             let expr13_0: Type = I64;
6370                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6371                             let expr15_0 = constructor_x64_xor(ctx, expr13_0, expr4_0, &expr14_0)?;
6372                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
6373                             let expr17_0 = C::output(ctx, expr16_0);
6374                             return Some(expr17_0);
6375                         }
6376                         &Opcode::Rotl => {
6377                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6378                             // Rule at src/isa/x64/lower.isle line 830.
6379                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6380                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6381                             let expr2_0 = constructor_shl_i128(ctx, expr0_0, expr1_0)?;
6382                             let expr3_0: Type = I64;
6383                             let expr4_0: Type = I64;
6384                             let expr5_0: u64 = 128;
6385                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
6386                             let expr7_0 = C::gpr_new(ctx, expr6_0);
6387                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
6388                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
6389                             let expr10_0 = constructor_shr_i128(ctx, expr0_0, expr9_0)?;
6390                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
6391                             let expr12_0 = C::output(ctx, expr11_0);
6392                             return Some(expr12_0);
6393                         }
6394                         &Opcode::Rotr => {
6395                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6396                             // Rule at src/isa/x64/lower.isle line 870.
6397                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6398                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6399                             let expr2_0 = constructor_shr_i128(ctx, expr0_0, expr1_0)?;
6400                             let expr3_0: Type = I64;
6401                             let expr4_0: Type = I64;
6402                             let expr5_0: u64 = 128;
6403                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
6404                             let expr7_0 = C::gpr_new(ctx, expr6_0);
6405                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
6406                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
6407                             let expr10_0 = constructor_shl_i128(ctx, expr0_0, expr9_0)?;
6408                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
6409                             let expr12_0 = C::output(ctx, expr11_0);
6410                             return Some(expr12_0);
6411                         }
6412                         &Opcode::Ishl => {
6413                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6414                             // Rule at src/isa/x64/lower.isle line 522.
6415                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6416                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
6417                             let expr2_0 = constructor_shl_i128(ctx, expr1_0, expr0_0)?;
6418                             let expr3_0 = C::output(ctx, expr2_0);
6419                             return Some(expr3_0);
6420                         }
6421                         &Opcode::Ushr => {
6422                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6423                             // Rule at src/isa/x64/lower.isle line 623.
6424                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6425                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
6426                             let expr2_0 = constructor_shr_i128(ctx, expr1_0, expr0_0)?;
6427                             let expr3_0 = C::output(ctx, expr2_0);
6428                             return Some(expr3_0);
6429                         }
6430                         &Opcode::Sshr => {
6431                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6432                             // Rule at src/isa/x64/lower.isle line 728.
6433                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6434                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
6435                             let expr2_0 = constructor_sar_i128(ctx, expr1_0, expr0_0)?;
6436                             let expr3_0 = C::output(ctx, expr2_0);
6437                             return Some(expr3_0);
6438                         }
6439                         _ => {}
6440                     }
6441                 }
6442                 &InstructionData::Unary {
6443                     opcode: ref pattern5_0,
6444                     arg: pattern5_1,
6445                 } => {
6446                     match pattern5_0 {
6447                         &Opcode::Bnot => {
6448                             // Rule at src/isa/x64/lower.isle line 1266.
6449                             let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
6450                             let expr1_0 = C::output(ctx, expr0_0);
6451                             return Some(expr1_0);
6452                         }
6453                         &Opcode::Bitrev => {
6454                             // Rule at src/isa/x64/lower.isle line 2025.
6455                             let expr0_0: Type = I64;
6456                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
6457                             let expr2_0: usize = 1;
6458                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
6459                             let expr4_0 = constructor_do_bitrev64(ctx, expr0_0, expr3_0)?;
6460                             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
6461                             let expr6_0: Type = I64;
6462                             let expr7_0 = C::put_in_regs(ctx, pattern5_1);
6463                             let expr8_0: usize = 0;
6464                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr7_0, expr8_0)?;
6465                             let expr10_0 = constructor_do_bitrev64(ctx, expr6_0, expr9_0)?;
6466                             let expr11_0 = C::gpr_to_reg(ctx, expr10_0);
6467                             let expr12_0 = C::value_regs(ctx, expr5_0, expr11_0);
6468                             let expr13_0 = C::output(ctx, expr12_0);
6469                             return Some(expr13_0);
6470                         }
6471                         &Opcode::Clz => {
6472                             // Rule at src/isa/x64/lower.isle line 1795.
6473                             let expr0_0: Type = I64;
6474                             let expr1_0: Type = I64;
6475                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
6476                             let expr3_0: usize = 1;
6477                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
6478                             let expr5_0 = constructor_do_clz(ctx, expr0_0, expr1_0, expr4_0)?;
6479                             let expr6_0: Type = I64;
6480                             let expr7_0: Type = I64;
6481                             let expr8_0: Type = I64;
6482                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
6483                             let expr10_0: usize = 0;
6484                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6485                             let expr12_0 = constructor_do_clz(ctx, expr7_0, expr8_0, expr11_0)?;
6486                             let expr13_0: u32 = 64;
6487                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
6488                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
6489                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
6490                             let expr17_0 = OperandSize::Size64;
6491                             let expr18_0: u32 = 64;
6492                             let expr19_0 =
6493                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
6494                             let expr20_0: Type = I64;
6495                             let expr21_0 = CC::NZ;
6496                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr5_0);
6497                             let expr23_0 =
6498                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr16_0)?;
6499                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
6500                             let expr25_0 = C::gpr_new(ctx, expr24_0);
6501                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
6502                             let expr27_0: Type = I64;
6503                             let expr28_0: u64 = 0;
6504                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
6505                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
6506                             let expr31_0 = C::output(ctx, expr30_0);
6507                             return Some(expr31_0);
6508                         }
6509                         &Opcode::Ctz => {
6510                             // Rule at src/isa/x64/lower.isle line 1837.
6511                             let expr0_0: Type = I64;
6512                             let expr1_0: Type = I64;
6513                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
6514                             let expr3_0: usize = 0;
6515                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
6516                             let expr5_0 = constructor_do_ctz(ctx, expr0_0, expr1_0, expr4_0)?;
6517                             let expr6_0: Type = I64;
6518                             let expr7_0: Type = I64;
6519                             let expr8_0: Type = I64;
6520                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
6521                             let expr10_0: usize = 1;
6522                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6523                             let expr12_0 = constructor_do_ctz(ctx, expr7_0, expr8_0, expr11_0)?;
6524                             let expr13_0: u32 = 64;
6525                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
6526                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
6527                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
6528                             let expr17_0 = OperandSize::Size64;
6529                             let expr18_0: u32 = 64;
6530                             let expr19_0 =
6531                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
6532                             let expr20_0: Type = I64;
6533                             let expr21_0 = CC::Z;
6534                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr16_0);
6535                             let expr23_0 =
6536                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr5_0)?;
6537                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
6538                             let expr25_0 = C::gpr_new(ctx, expr24_0);
6539                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
6540                             let expr27_0: Type = I64;
6541                             let expr28_0: u64 = 0;
6542                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
6543                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
6544                             let expr31_0 = C::output(ctx, expr30_0);
6545                             return Some(expr31_0);
6546                         }
6547                         &Opcode::Popcnt => {
6548                             // Rule at src/isa/x64/lower.isle line 1889.
6549                             let expr0_0: Type = I64;
6550                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
6551                             let expr2_0: usize = 0;
6552                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
6553                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
6554                             let expr5_0: Type = I64;
6555                             let expr6_0 = C::put_in_regs(ctx, pattern5_1);
6556                             let expr7_0: usize = 1;
6557                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6558                             let expr9_0 = constructor_do_popcnt(ctx, expr5_0, expr8_0)?;
6559                             let expr10_0: Type = I64;
6560                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6561                             let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
6562                             let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
6563                             let expr14_0: Type = I64;
6564                             let expr15_0: u64 = 0;
6565                             let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
6566                             let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
6567                             let expr18_0 = C::output(ctx, expr17_0);
6568                             return Some(expr18_0);
6569                         }
6570                         &Opcode::Bint => {
6571                             // Rule at src/isa/x64/lower.isle line 2240.
6572                             let expr0_0: Type = I64;
6573                             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6574                             let expr2_0: u32 = 1;
6575                             let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
6576                             let expr4_0 = C::gpr_mem_imm_new(ctx, &expr3_0);
6577                             let expr5_0 = constructor_x64_and(ctx, expr0_0, expr1_0, &expr4_0)?;
6578                             let expr6_0 = C::gpr_to_reg(ctx, expr5_0);
6579                             let expr7_0: Type = I64;
6580                             let expr8_0: u64 = 0;
6581                             let expr9_0 = constructor_imm(ctx, expr7_0, expr8_0)?;
6582                             let expr10_0 = C::value_regs(ctx, expr6_0, expr9_0);
6583                             let expr11_0 = C::output(ctx, expr10_0);
6584                             return Some(expr11_0);
6585                         }
6586                         &Opcode::Uextend => {
6587                             let pattern7_0 = C::value_type(ctx, pattern5_1);
6588                             if pattern7_0 == I64 {
6589                                 // Rule at src/isa/x64/lower.isle line 2112.
6590                                 let expr0_0 = C::put_in_reg(ctx, pattern5_1);
6591                                 let expr1_0: Type = I64;
6592                                 let expr2_0: u64 = 0;
6593                                 let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
6594                                 let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
6595                                 let expr5_0 = C::output(ctx, expr4_0);
6596                                 return Some(expr5_0);
6597                             }
6598                             if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
6599                                 // Rule at src/isa/x64/lower.isle line 2116.
6600                                 let expr0_0: Type = I64;
6601                                 let expr1_0 = ExtendKind::Zero;
6602                                 let expr2_0 =
6603                                     constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
6604                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
6605                                 let expr4_0: Type = I64;
6606                                 let expr5_0: u64 = 0;
6607                                 let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
6608                                 let expr7_0 = C::value_regs(ctx, expr3_0, expr6_0);
6609                                 let expr8_0 = C::output(ctx, expr7_0);
6610                                 return Some(expr8_0);
6611                             }
6612                         }
6613                         _ => {}
6614                     }
6615                 }
6616                 &InstructionData::BinaryImm64 {
6617                     opcode: ref pattern5_0,
6618                     arg: pattern5_1,
6619                     imm: pattern5_2,
6620                 } => {
6621                     if let &Opcode::IaddImm = pattern5_0 {
6622                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
6623                         // Rule at src/isa/x64/lower.isle line 210.
6624                         let expr0_0 = C::put_in_regs(ctx, pattern5_1);
6625                         let expr1_0: usize = 0;
6626                         let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6627                         let expr3_0: usize = 1;
6628                         let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6629                         let expr5_0: Type = I64;
6630                         let expr6_0 = constructor_imm(ctx, expr5_0, pattern7_0)?;
6631                         let expr7_0 = C::gpr_new(ctx, expr6_0);
6632                         let expr8_0: Type = I64;
6633                         let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6634                         let expr10_0 =
6635                             constructor_x64_add_with_flags_paired(ctx, expr8_0, expr2_0, &expr9_0)?;
6636                         let expr11_0: Type = I64;
6637                         let expr12_0: u32 = 0;
6638                         let expr13_0 = RegMemImm::Imm { simm32: expr12_0 };
6639                         let expr14_0 = C::gpr_mem_imm_new(ctx, &expr13_0);
6640                         let expr15_0 =
6641                             constructor_x64_adc_paired(ctx, expr11_0, expr4_0, &expr14_0)?;
6642                         let expr16_0 = constructor_with_flags(ctx, &expr10_0, &expr15_0)?;
6643                         let expr17_0 = C::output(ctx, expr16_0);
6644                         return Some(expr17_0);
6645                     }
6646                 }
6647                 _ => {}
6648             }
6649         }
6650         if pattern2_0 == F32 {
6651             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6652             match &pattern4_0 {
6653                 &InstructionData::Binary {
6654                     opcode: ref pattern5_0,
6655                     args: ref pattern5_1,
6656                 } => {
6657                     match pattern5_0 {
6658                         &Opcode::Fadd => {
6659                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6660                             // Rule at src/isa/x64/lower.isle line 2263.
6661                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6662                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6663                             let expr2_0 = constructor_x64_addss(ctx, expr0_0, &expr1_0)?;
6664                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6665                             return Some(expr3_0);
6666                         }
6667                         &Opcode::Fsub => {
6668                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6669                             // Rule at src/isa/x64/lower.isle line 2274.
6670                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6671                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6672                             let expr2_0 = constructor_x64_subss(ctx, expr0_0, &expr1_0)?;
6673                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6674                             return Some(expr3_0);
6675                         }
6676                         &Opcode::Fmul => {
6677                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6678                             // Rule at src/isa/x64/lower.isle line 2285.
6679                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6680                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6681                             let expr2_0 = constructor_x64_mulss(ctx, expr0_0, &expr1_0)?;
6682                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6683                             return Some(expr3_0);
6684                         }
6685                         &Opcode::Fdiv => {
6686                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6687                             // Rule at src/isa/x64/lower.isle line 2296.
6688                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6689                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6690                             let expr2_0 = constructor_x64_divss(ctx, expr0_0, &expr1_0)?;
6691                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6692                             return Some(expr3_0);
6693                         }
6694                         &Opcode::Fmin => {
6695                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6696                             // Rule at src/isa/x64/lower.isle line 2317.
6697                             let expr0_0: Type = F32;
6698                             let expr1_0: bool = true;
6699                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6700                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6701                             let expr4_0 = constructor_xmm_min_max_seq(
6702                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6703                             )?;
6704                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6705                             return Some(expr5_0);
6706                         }
6707                         &Opcode::FminPseudo => {
6708                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6709                             // Rule at src/isa/x64/lower.isle line 2486.
6710                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6711                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6712                             let expr2_0 = constructor_x64_minss(ctx, expr0_0, expr1_0)?;
6713                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6714                             return Some(expr3_0);
6715                         }
6716                         &Opcode::Fmax => {
6717                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6718                             // Rule at src/isa/x64/lower.isle line 2389.
6719                             let expr0_0: Type = F32;
6720                             let expr1_0: bool = false;
6721                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6722                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6723                             let expr4_0 = constructor_xmm_min_max_seq(
6724                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6725                             )?;
6726                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6727                             return Some(expr5_0);
6728                         }
6729                         &Opcode::FmaxPseudo => {
6730                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6731                             // Rule at src/isa/x64/lower.isle line 2497.
6732                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6733                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6734                             let expr2_0 = constructor_x64_maxss(ctx, expr0_0, expr1_0)?;
6735                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6736                             return Some(expr3_0);
6737                         }
6738                         _ => {}
6739                     }
6740                 }
6741                 &InstructionData::Unary {
6742                     opcode: ref pattern5_0,
6743                     arg: pattern5_1,
6744                 } => {
6745                     if let &Opcode::Sqrt = pattern5_0 {
6746                         // Rule at src/isa/x64/lower.isle line 2306.
6747                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
6748                         let expr1_0 = constructor_x64_sqrtss(ctx, expr0_0)?;
6749                         let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
6750                         return Some(expr2_0);
6751                     }
6752                 }
6753                 &InstructionData::Load {
6754                     opcode: ref pattern5_0,
6755                     arg: pattern5_1,
6756                     flags: pattern5_2,
6757                     offset: pattern5_3,
6758                 } => {
6759                     if let &Opcode::Load = pattern5_0 {
6760                         // Rule at src/isa/x64/lower.isle line 2540.
6761                         let expr0_0 =
6762                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
6763                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
6764                         let expr2_0 = constructor_x64_movss_load(ctx, &expr1_0)?;
6765                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6766                         return Some(expr3_0);
6767                     }
6768                 }
6769                 _ => {}
6770             }
6771         }
6772         if pattern2_0 == F64 {
6773             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6774             match &pattern4_0 {
6775                 &InstructionData::Binary {
6776                     opcode: ref pattern5_0,
6777                     args: ref pattern5_1,
6778                 } => {
6779                     match pattern5_0 {
6780                         &Opcode::Fadd => {
6781                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6782                             // Rule at src/isa/x64/lower.isle line 2265.
6783                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6784                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6785                             let expr2_0 = constructor_x64_addsd(ctx, expr0_0, &expr1_0)?;
6786                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6787                             return Some(expr3_0);
6788                         }
6789                         &Opcode::Fsub => {
6790                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6791                             // Rule at src/isa/x64/lower.isle line 2276.
6792                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6793                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6794                             let expr2_0 = constructor_x64_subsd(ctx, expr0_0, &expr1_0)?;
6795                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6796                             return Some(expr3_0);
6797                         }
6798                         &Opcode::Fmul => {
6799                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6800                             // Rule at src/isa/x64/lower.isle line 2287.
6801                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6802                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6803                             let expr2_0 = constructor_x64_mulsd(ctx, expr0_0, &expr1_0)?;
6804                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6805                             return Some(expr3_0);
6806                         }
6807                         &Opcode::Fdiv => {
6808                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6809                             // Rule at src/isa/x64/lower.isle line 2298.
6810                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6811                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6812                             let expr2_0 = constructor_x64_divsd(ctx, expr0_0, &expr1_0)?;
6813                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6814                             return Some(expr3_0);
6815                         }
6816                         &Opcode::Fmin => {
6817                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6818                             // Rule at src/isa/x64/lower.isle line 2319.
6819                             let expr0_0: Type = F64;
6820                             let expr1_0: bool = true;
6821                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6822                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6823                             let expr4_0 = constructor_xmm_min_max_seq(
6824                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6825                             )?;
6826                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6827                             return Some(expr5_0);
6828                         }
6829                         &Opcode::FminPseudo => {
6830                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6831                             // Rule at src/isa/x64/lower.isle line 2488.
6832                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6833                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6834                             let expr2_0 = constructor_x64_minsd(ctx, expr0_0, expr1_0)?;
6835                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6836                             return Some(expr3_0);
6837                         }
6838                         &Opcode::Fmax => {
6839                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6840                             // Rule at src/isa/x64/lower.isle line 2391.
6841                             let expr0_0: Type = F64;
6842                             let expr1_0: bool = false;
6843                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6844                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6845                             let expr4_0 = constructor_xmm_min_max_seq(
6846                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6847                             )?;
6848                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6849                             return Some(expr5_0);
6850                         }
6851                         &Opcode::FmaxPseudo => {
6852                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6853                             // Rule at src/isa/x64/lower.isle line 2499.
6854                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6855                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6856                             let expr2_0 = constructor_x64_maxsd(ctx, expr0_0, expr1_0)?;
6857                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6858                             return Some(expr3_0);
6859                         }
6860                         _ => {}
6861                     }
6862                 }
6863                 &InstructionData::Unary {
6864                     opcode: ref pattern5_0,
6865                     arg: pattern5_1,
6866                 } => {
6867                     if let &Opcode::Sqrt = pattern5_0 {
6868                         // Rule at src/isa/x64/lower.isle line 2308.
6869                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
6870                         let expr1_0 = constructor_x64_sqrtsd(ctx, expr0_0)?;
6871                         let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
6872                         return Some(expr2_0);
6873                     }
6874                 }
6875                 &InstructionData::Load {
6876                     opcode: ref pattern5_0,
6877                     arg: pattern5_1,
6878                     flags: pattern5_2,
6879                     offset: pattern5_3,
6880                 } => {
6881                     if let &Opcode::Load = pattern5_0 {
6882                         // Rule at src/isa/x64/lower.isle line 2542.
6883                         let expr0_0 =
6884                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
6885                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
6886                         let expr2_0 = constructor_x64_movsd_load(ctx, &expr1_0)?;
6887                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6888                         return Some(expr3_0);
6889                     }
6890                 }
6891                 _ => {}
6892             }
6893         }
6894         if pattern2_0 == I8X16 {
6895             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6896             match &pattern4_0 {
6897                 &InstructionData::Binary {
6898                     opcode: ref pattern5_0,
6899                     args: ref pattern5_1,
6900                 } => {
6901                     match pattern5_0 {
6902                         &Opcode::Imin => {
6903                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6904                             // Rule at src/isa/x64/lower.isle line 1399.
6905                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6906                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6907                             let expr2_0 = constructor_x64_pminsb(ctx, expr0_0, &expr1_0)?;
6908                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6909                             return Some(expr3_0);
6910                         }
6911                         &Opcode::Umin => {
6912                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6913                             // Rule at src/isa/x64/lower.isle line 1421.
6914                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6915                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6916                             let expr2_0 = constructor_x64_pminub(ctx, expr0_0, &expr1_0)?;
6917                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6918                             return Some(expr3_0);
6919                         }
6920                         &Opcode::Imax => {
6921                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6922                             // Rule at src/isa/x64/lower.isle line 1388.
6923                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6924                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6925                             let expr2_0 = constructor_x64_pmaxsb(ctx, expr0_0, &expr1_0)?;
6926                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6927                             return Some(expr3_0);
6928                         }
6929                         &Opcode::Umax => {
6930                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6931                             // Rule at src/isa/x64/lower.isle line 1410.
6932                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6933                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6934                             let expr2_0 = constructor_x64_pmaxub(ctx, expr0_0, &expr1_0)?;
6935                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6936                             return Some(expr3_0);
6937                         }
6938                         &Opcode::Ishl => {
6939                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6940                             // Rule at src/isa/x64/lower.isle line 534.
6941                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6942                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6943                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
6944                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
6945                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6946                             let expr5_0 = constructor_ishl_i8x16_mask(ctx, &expr4_0)?;
6947                             let expr6_0: Type = I8X16;
6948                             let expr7_0 = ExtKind::None;
6949                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
6950                             let expr9_0: Type = I8X16;
6951                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
6952                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
6953                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
6954                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
6955                             return Some(expr13_0);
6956                         }
6957                         &Opcode::Ushr => {
6958                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6959                             // Rule at src/isa/x64/lower.isle line 633.
6960                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6961                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6962                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
6963                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
6964                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6965                             let expr5_0 = constructor_ushr_i8x16_mask(ctx, &expr4_0)?;
6966                             let expr6_0: Type = I8X16;
6967                             let expr7_0 = ExtKind::None;
6968                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
6969                             let expr9_0: Type = I8X16;
6970                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
6971                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
6972                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
6973                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
6974                             return Some(expr13_0);
6975                         }
6976                         &Opcode::Sshr => {
6977                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6978                             let pattern8_0 = C::value_type(ctx, pattern7_1);
6979                             // Rule at src/isa/x64/lower.isle line 749.
6980                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6981                             let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
6982                             let expr2_0 = constructor_x64_punpcklbw(ctx, expr0_0, &expr1_0)?;
6983                             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
6984                             let expr4_0 = constructor_x64_punpckhbw(ctx, expr0_0, &expr3_0)?;
6985                             let expr5_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6986                             let expr6_0 =
6987                                 constructor_sshr_i8x16_bigger_shift(ctx, pattern8_0, &expr5_0)?;
6988                             let expr7_0 = constructor_x64_psraw(ctx, expr2_0, &expr6_0)?;
6989                             let expr8_0 = constructor_x64_psraw(ctx, expr4_0, &expr6_0)?;
6990                             let expr9_0 = C::xmm_to_xmm_mem(ctx, expr8_0);
6991                             let expr10_0 = constructor_x64_packsswb(ctx, expr7_0, &expr9_0)?;
6992                             let expr11_0 = constructor_output_xmm(ctx, expr10_0)?;
6993                             return Some(expr11_0);
6994                         }
6995                         _ => {}
6996                     }
6997                 }
6998                 &InstructionData::Unary {
6999                     opcode: ref pattern5_0,
7000                     arg: pattern5_1,
7001                 } => {
7002                     match pattern5_0 {
7003                         &Opcode::Ineg => {
7004                             // Rule at src/isa/x64/lower.isle line 889.
7005                             let expr0_0: Type = I8X16;
7006                             let expr1_0: u64 = 0;
7007                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7008                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7009                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7010                             let expr5_0 = constructor_x64_psubb(ctx, expr3_0, &expr4_0)?;
7011                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7012                             return Some(expr6_0);
7013                         }
7014                         &Opcode::Iabs => {
7015                             // Rule at src/isa/x64/lower.isle line 1210.
7016                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7017                             let expr1_0 = constructor_x64_pabsb(ctx, &expr0_0)?;
7018                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7019                             return Some(expr2_0);
7020                         }
7021                         &Opcode::Popcnt => {
7022                             // Rule at src/isa/x64/lower.isle line 1996.
7023                             let expr0_0 = C::popcount_4bit_table(ctx);
7024                             let expr1_0: Type = I8X16;
7025                             let expr2_0 = C::popcount_low_mask(ctx);
7026                             let expr3_0 = constructor_x64_xmm_load_const(ctx, expr1_0, expr2_0)?;
7027                             let expr4_0: Type = I8X16;
7028                             let expr5_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7029                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
7030                             let expr7_0 = constructor_sse_and(ctx, expr4_0, expr5_0, &expr6_0)?;
7031                             let expr8_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7032                             let expr9_0: u32 = 4;
7033                             let expr10_0 = RegMemImm::Imm { simm32: expr9_0 };
7034                             let expr11_0 = constructor_mov_rmi_to_xmm(ctx, &expr10_0)?;
7035                             let expr12_0 = constructor_x64_psrlw(ctx, expr8_0, &expr11_0)?;
7036                             let expr13_0: Type = I8X16;
7037                             let expr14_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
7038                             let expr15_0 = constructor_sse_and(ctx, expr13_0, expr12_0, &expr14_0)?;
7039                             let expr16_0: Type = I8X16;
7040                             let expr17_0 = C::popcount_4bit_table(ctx);
7041                             let expr18_0 = constructor_x64_xmm_load_const(ctx, expr16_0, expr17_0)?;
7042                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7043                             let expr20_0 = constructor_x64_pshufb(ctx, expr18_0, &expr19_0)?;
7044                             let expr21_0 = C::xmm_to_xmm_mem(ctx, expr15_0);
7045                             let expr22_0 = constructor_x64_pshufb(ctx, expr18_0, &expr21_0)?;
7046                             let expr23_0 = C::xmm_to_xmm_mem(ctx, expr22_0);
7047                             let expr24_0 = constructor_x64_paddb(ctx, expr20_0, &expr23_0)?;
7048                             let expr25_0 = constructor_output_xmm(ctx, expr24_0)?;
7049                             return Some(expr25_0);
7050                         }
7051                         _ => {}
7052                     }
7053                 }
7054                 _ => {}
7055             }
7056         }
7057         if pattern2_0 == I16X8 {
7058             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7059             match &pattern4_0 {
7060                 &InstructionData::Binary {
7061                     opcode: ref pattern5_0,
7062                     args: ref pattern5_1,
7063                 } => {
7064                     match pattern5_0 {
7065                         &Opcode::Imin => {
7066                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7067                             // Rule at src/isa/x64/lower.isle line 1402.
7068                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7069                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7070                             let expr2_0 = constructor_x64_pminsw(ctx, expr0_0, &expr1_0)?;
7071                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7072                             return Some(expr3_0);
7073                         }
7074                         &Opcode::Umin => {
7075                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7076                             // Rule at src/isa/x64/lower.isle line 1424.
7077                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7078                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7079                             let expr2_0 = constructor_x64_pminuw(ctx, expr0_0, &expr1_0)?;
7080                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7081                             return Some(expr3_0);
7082                         }
7083                         &Opcode::Imax => {
7084                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7085                             // Rule at src/isa/x64/lower.isle line 1391.
7086                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7087                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7088                             let expr2_0 = constructor_x64_pmaxsw(ctx, expr0_0, &expr1_0)?;
7089                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7090                             return Some(expr3_0);
7091                         }
7092                         &Opcode::Umax => {
7093                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7094                             // Rule at src/isa/x64/lower.isle line 1413.
7095                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7096                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7097                             let expr2_0 = constructor_x64_pmaxuw(ctx, expr0_0, &expr1_0)?;
7098                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7099                             return Some(expr3_0);
7100                         }
7101                         &Opcode::Ishl => {
7102                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7103                             // Rule at src/isa/x64/lower.isle line 576.
7104                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7105                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7106                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7107                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
7108                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7109                             return Some(expr4_0);
7110                         }
7111                         &Opcode::Ushr => {
7112                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7113                             // Rule at src/isa/x64/lower.isle line 678.
7114                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7115                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7116                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7117                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
7118                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7119                             return Some(expr4_0);
7120                         }
7121                         &Opcode::Sshr => {
7122                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7123                             // Rule at src/isa/x64/lower.isle line 776.
7124                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7125                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7126                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7127                             let expr3_0 = constructor_x64_psraw(ctx, expr0_0, &expr2_0)?;
7128                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7129                             return Some(expr4_0);
7130                         }
7131                         _ => {}
7132                     }
7133                 }
7134                 &InstructionData::Unary {
7135                     opcode: ref pattern5_0,
7136                     arg: pattern5_1,
7137                 } => {
7138                     match pattern5_0 {
7139                         &Opcode::Ineg => {
7140                             // Rule at src/isa/x64/lower.isle line 892.
7141                             let expr0_0: Type = I16X8;
7142                             let expr1_0: u64 = 0;
7143                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7144                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7145                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7146                             let expr5_0 = constructor_x64_psubw(ctx, expr3_0, &expr4_0)?;
7147                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7148                             return Some(expr6_0);
7149                         }
7150                         &Opcode::Iabs => {
7151                             // Rule at src/isa/x64/lower.isle line 1213.
7152                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7153                             let expr1_0 = constructor_x64_pabsw(ctx, &expr0_0)?;
7154                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7155                             return Some(expr2_0);
7156                         }
7157                         _ => {}
7158                     }
7159                 }
7160                 &InstructionData::Load {
7161                     opcode: ref pattern5_0,
7162                     arg: pattern5_1,
7163                     flags: pattern5_2,
7164                     offset: pattern5_3,
7165                 } => {
7166                     match pattern5_0 {
7167                         &Opcode::Uload8x8 => {
7168                             // Rule at src/isa/x64/lower.isle line 2555.
7169                             let expr0_0 =
7170                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7171                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7172                             let expr2_0 = constructor_x64_pmovzxbw(ctx, &expr1_0)?;
7173                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7174                             return Some(expr3_0);
7175                         }
7176                         &Opcode::Sload8x8 => {
7177                             // Rule at src/isa/x64/lower.isle line 2553.
7178                             let expr0_0 =
7179                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7180                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7181                             let expr2_0 = constructor_x64_pmovsxbw(ctx, &expr1_0)?;
7182                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7183                             return Some(expr3_0);
7184                         }
7185                         _ => {}
7186                     }
7187                 }
7188                 _ => {}
7189             }
7190         }
7191         if pattern2_0 == I32X4 {
7192             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7193             match &pattern4_0 {
7194                 &InstructionData::Binary {
7195                     opcode: ref pattern5_0,
7196                     args: ref pattern5_1,
7197                 } => {
7198                     match pattern5_0 {
7199                         &Opcode::Imin => {
7200                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7201                             // Rule at src/isa/x64/lower.isle line 1405.
7202                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7203                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7204                             let expr2_0 = constructor_x64_pminsd(ctx, expr0_0, &expr1_0)?;
7205                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7206                             return Some(expr3_0);
7207                         }
7208                         &Opcode::Umin => {
7209                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7210                             // Rule at src/isa/x64/lower.isle line 1427.
7211                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7212                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7213                             let expr2_0 = constructor_x64_pminud(ctx, expr0_0, &expr1_0)?;
7214                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7215                             return Some(expr3_0);
7216                         }
7217                         &Opcode::Imax => {
7218                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7219                             // Rule at src/isa/x64/lower.isle line 1394.
7220                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7221                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7222                             let expr2_0 = constructor_x64_pmaxsd(ctx, expr0_0, &expr1_0)?;
7223                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7224                             return Some(expr3_0);
7225                         }
7226                         &Opcode::Umax => {
7227                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7228                             // Rule at src/isa/x64/lower.isle line 1416.
7229                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7230                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7231                             let expr2_0 = constructor_x64_pmaxud(ctx, expr0_0, &expr1_0)?;
7232                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7233                             return Some(expr3_0);
7234                         }
7235                         &Opcode::Ishl => {
7236                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7237                             // Rule at src/isa/x64/lower.isle line 579.
7238                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7239                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7240                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7241                             let expr3_0 = constructor_x64_pslld(ctx, expr0_0, &expr2_0)?;
7242                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7243                             return Some(expr4_0);
7244                         }
7245                         &Opcode::Ushr => {
7246                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7247                             // Rule at src/isa/x64/lower.isle line 681.
7248                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7249                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7250                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7251                             let expr3_0 = constructor_x64_psrld(ctx, expr0_0, &expr2_0)?;
7252                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7253                             return Some(expr4_0);
7254                         }
7255                         &Opcode::Sshr => {
7256                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7257                             // Rule at src/isa/x64/lower.isle line 779.
7258                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7259                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7260                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7261                             let expr3_0 = constructor_x64_psrad(ctx, expr0_0, &expr2_0)?;
7262                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7263                             return Some(expr4_0);
7264                         }
7265                         &Opcode::WideningPairwiseDotProductS => {
7266                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7267                             // Rule at src/isa/x64/lower.isle line 2253.
7268                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7269                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7270                             let expr2_0 = constructor_x64_pmaddwd(ctx, expr0_0, &expr1_0)?;
7271                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7272                             return Some(expr3_0);
7273                         }
7274                         _ => {}
7275                     }
7276                 }
7277                 &InstructionData::Unary {
7278                     opcode: ref pattern5_0,
7279                     arg: pattern5_1,
7280                 } => {
7281                     match pattern5_0 {
7282                         &Opcode::Ineg => {
7283                             // Rule at src/isa/x64/lower.isle line 895.
7284                             let expr0_0: Type = I32X4;
7285                             let expr1_0: u64 = 0;
7286                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7287                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7288                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7289                             let expr5_0 = constructor_x64_psubd(ctx, expr3_0, &expr4_0)?;
7290                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7291                             return Some(expr6_0);
7292                         }
7293                         &Opcode::Iabs => {
7294                             // Rule at src/isa/x64/lower.isle line 1216.
7295                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7296                             let expr1_0 = constructor_x64_pabsd(ctx, &expr0_0)?;
7297                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7298                             return Some(expr2_0);
7299                         }
7300                         _ => {}
7301                     }
7302                 }
7303                 &InstructionData::Load {
7304                     opcode: ref pattern5_0,
7305                     arg: pattern5_1,
7306                     flags: pattern5_2,
7307                     offset: pattern5_3,
7308                 } => {
7309                     match pattern5_0 {
7310                         &Opcode::Uload16x4 => {
7311                             // Rule at src/isa/x64/lower.isle line 2559.
7312                             let expr0_0 =
7313                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7314                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7315                             let expr2_0 = constructor_x64_pmovzxwd(ctx, &expr1_0)?;
7316                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7317                             return Some(expr3_0);
7318                         }
7319                         &Opcode::Sload16x4 => {
7320                             // Rule at src/isa/x64/lower.isle line 2557.
7321                             let expr0_0 =
7322                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7323                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7324                             let expr2_0 = constructor_x64_pmovsxwd(ctx, &expr1_0)?;
7325                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7326                             return Some(expr3_0);
7327                         }
7328                         _ => {}
7329                     }
7330                 }
7331                 _ => {}
7332             }
7333         }
7334         if pattern2_0 == I64X2 {
7335             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7336             match &pattern4_0 {
7337                 &InstructionData::Binary {
7338                     opcode: ref pattern5_0,
7339                     args: ref pattern5_1,
7340                 } => {
7341                     match pattern5_0 {
7342                         &Opcode::Ishl => {
7343                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7344                             // Rule at src/isa/x64/lower.isle line 582.
7345                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7346                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7347                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7348                             let expr3_0 = constructor_x64_psllq(ctx, expr0_0, &expr2_0)?;
7349                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7350                             return Some(expr4_0);
7351                         }
7352                         &Opcode::Ushr => {
7353                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7354                             // Rule at src/isa/x64/lower.isle line 684.
7355                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7356                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7357                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7358                             let expr3_0 = constructor_x64_psrlq(ctx, expr0_0, &expr2_0)?;
7359                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7360                             return Some(expr4_0);
7361                         }
7362                         &Opcode::Sshr => {
7363                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7364                             // Rule at src/isa/x64/lower.isle line 790.
7365                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7366                             let expr1_0: Type = I64;
7367                             let expr2_0: u8 = 0;
7368                             let expr3_0 = constructor_x64_pextrd(ctx, expr1_0, expr0_0, expr2_0)?;
7369                             let expr4_0: Type = I64;
7370                             let expr5_0: u8 = 1;
7371                             let expr6_0 = constructor_x64_pextrd(ctx, expr4_0, expr0_0, expr5_0)?;
7372                             let expr7_0: Type = I64;
7373                             let expr8_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, expr7_0);
7374                             let expr9_0: Type = I64;
7375                             let expr10_0 = constructor_x64_sar(ctx, expr9_0, expr3_0, &expr8_0)?;
7376                             let expr11_0: Type = I64;
7377                             let expr12_0 = constructor_x64_sar(ctx, expr11_0, expr6_0, &expr8_0)?;
7378                             let expr13_0 = C::gpr_to_gpr_mem(ctx, expr10_0);
7379                             let expr14_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
7380                             let expr15_0 =
7381                                 constructor_make_i64x2_from_lanes(ctx, &expr13_0, &expr14_0)?;
7382                             let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
7383                             return Some(expr16_0);
7384                         }
7385                         _ => {}
7386                     }
7387                 }
7388                 &InstructionData::Unary {
7389                     opcode: ref pattern5_0,
7390                     arg: pattern5_1,
7391                 } => {
7392                     match pattern5_0 {
7393                         &Opcode::Ineg => {
7394                             // Rule at src/isa/x64/lower.isle line 898.
7395                             let expr0_0: Type = I64X2;
7396                             let expr1_0: u64 = 0;
7397                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7398                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7399                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7400                             let expr5_0 = constructor_x64_psubq(ctx, expr3_0, &expr4_0)?;
7401                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7402                             return Some(expr6_0);
7403                         }
7404                         &Opcode::Iabs => {
7405                             // Rule at src/isa/x64/lower.isle line 1230.
7406                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7407                             let expr1_0: Type = I64X2;
7408                             let expr2_0: u64 = 0;
7409                             let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
7410                             let expr4_0 = C::xmm_new(ctx, expr3_0);
7411                             let expr5_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
7412                             let expr6_0 = constructor_x64_psubq(ctx, expr4_0, &expr5_0)?;
7413                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
7414                             let expr8_0 =
7415                                 constructor_x64_blendvpd(ctx, expr6_0, &expr7_0, expr6_0)?;
7416                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
7417                             return Some(expr9_0);
7418                         }
7419                         _ => {}
7420                     }
7421                 }
7422                 &InstructionData::Load {
7423                     opcode: ref pattern5_0,
7424                     arg: pattern5_1,
7425                     flags: pattern5_2,
7426                     offset: pattern5_3,
7427                 } => {
7428                     match pattern5_0 {
7429                         &Opcode::Uload32x2 => {
7430                             // Rule at src/isa/x64/lower.isle line 2563.
7431                             let expr0_0 =
7432                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7433                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7434                             let expr2_0 = constructor_x64_pmovzxdq(ctx, &expr1_0)?;
7435                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7436                             return Some(expr3_0);
7437                         }
7438                         &Opcode::Sload32x2 => {
7439                             // Rule at src/isa/x64/lower.isle line 2561.
7440                             let expr0_0 =
7441                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7442                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7443                             let expr2_0 = constructor_x64_pmovsxdq(ctx, &expr1_0)?;
7444                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7445                             return Some(expr3_0);
7446                         }
7447                         _ => {}
7448                     }
7449                 }
7450                 _ => {}
7451             }
7452         }
7453         if pattern2_0 == F32X4 {
7454             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7455             match &pattern4_0 {
7456                 &InstructionData::Binary {
7457                     opcode: ref pattern5_0,
7458                     args: ref pattern5_1,
7459                 } => {
7460                     match pattern5_0 {
7461                         &Opcode::Fadd => {
7462                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7463                             // Rule at src/isa/x64/lower.isle line 2267.
7464                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7465                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7466                             let expr2_0 = constructor_x64_addps(ctx, expr0_0, &expr1_0)?;
7467                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7468                             return Some(expr3_0);
7469                         }
7470                         &Opcode::Fsub => {
7471                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7472                             // Rule at src/isa/x64/lower.isle line 2278.
7473                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7474                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7475                             let expr2_0 = constructor_x64_subps(ctx, expr0_0, &expr1_0)?;
7476                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7477                             return Some(expr3_0);
7478                         }
7479                         &Opcode::Fmul => {
7480                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7481                             // Rule at src/isa/x64/lower.isle line 2289.
7482                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7483                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7484                             let expr2_0 = constructor_x64_mulps(ctx, expr0_0, &expr1_0)?;
7485                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7486                             return Some(expr3_0);
7487                         }
7488                         &Opcode::Fdiv => {
7489                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7490                             // Rule at src/isa/x64/lower.isle line 2300.
7491                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7492                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7493                             let expr2_0 = constructor_x64_divps(ctx, expr0_0, &expr1_0)?;
7494                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7495                             return Some(expr3_0);
7496                         }
7497                         &Opcode::Fmin => {
7498                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7499                             // Rule at src/isa/x64/lower.isle line 2334.
7500                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7501                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7502                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
7503                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7504                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7505                             let expr5_0 = constructor_x64_minps(ctx, expr3_0, expr4_0)?;
7506                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7507                             let expr7_0 = constructor_x64_orps(ctx, expr2_0, &expr6_0)?;
7508                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7509                             let expr9_0 = FcmpImm::Unordered;
7510                             let expr10_0 = constructor_x64_cmpps(ctx, expr7_0, &expr8_0, &expr9_0)?;
7511                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
7512                             let expr12_0 = constructor_x64_orps(ctx, expr7_0, &expr11_0)?;
7513                             let expr13_0: u32 = 10;
7514                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7515                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
7516                             let expr16_0 = constructor_x64_psrld(ctx, expr10_0, &expr15_0)?;
7517                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
7518                             let expr18_0 = constructor_x64_andnps(ctx, expr16_0, &expr17_0)?;
7519                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
7520                             return Some(expr19_0);
7521                         }
7522                         &Opcode::FminPseudo => {
7523                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7524                             // Rule at src/isa/x64/lower.isle line 2490.
7525                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7526                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7527                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
7528                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7529                             return Some(expr3_0);
7530                         }
7531                         &Opcode::Fmax => {
7532                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7533                             // Rule at src/isa/x64/lower.isle line 2397.
7534                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7535                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7536                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
7537                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7538                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7539                             let expr5_0 = constructor_x64_maxps(ctx, expr3_0, expr4_0)?;
7540                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7541                             let expr7_0 = constructor_x64_xorps(ctx, expr2_0, &expr6_0)?;
7542                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7543                             let expr9_0 = constructor_x64_orps(ctx, expr2_0, &expr8_0)?;
7544                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7545                             let expr11_0 = constructor_x64_subps(ctx, expr9_0, &expr10_0)?;
7546                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
7547                             let expr13_0 = FcmpImm::Unordered;
7548                             let expr14_0 =
7549                                 constructor_x64_cmpps(ctx, expr9_0, &expr12_0, &expr13_0)?;
7550                             let expr15_0: u32 = 10;
7551                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
7552                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
7553                             let expr18_0 = constructor_x64_psrld(ctx, expr14_0, &expr17_0)?;
7554                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
7555                             let expr20_0 = constructor_x64_andnps(ctx, expr18_0, &expr19_0)?;
7556                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
7557                             return Some(expr21_0);
7558                         }
7559                         &Opcode::FmaxPseudo => {
7560                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7561                             // Rule at src/isa/x64/lower.isle line 2501.
7562                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7563                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7564                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
7565                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7566                             return Some(expr3_0);
7567                         }
7568                         _ => {}
7569                     }
7570                 }
7571                 &InstructionData::Unary {
7572                     opcode: ref pattern5_0,
7573                     arg: pattern5_1,
7574                 } => {
7575                     match pattern5_0 {
7576                         &Opcode::Sqrt => {
7577                             // Rule at src/isa/x64/lower.isle line 2310.
7578                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7579                             let expr1_0 = constructor_x64_sqrtps(ctx, expr0_0)?;
7580                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7581                             return Some(expr2_0);
7582                         }
7583                         &Opcode::Fabs => {
7584                             // Rule at src/isa/x64/lower.isle line 1238.
7585                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7586                             let expr1_0: Type = F32X4;
7587                             let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
7588                             let expr3_0: u32 = 1;
7589                             let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
7590                             let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
7591                             let expr6_0 = constructor_x64_psrld(ctx, expr2_0, &expr5_0)?;
7592                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
7593                             let expr8_0 = constructor_x64_andps(ctx, expr0_0, &expr7_0)?;
7594                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
7595                             return Some(expr9_0);
7596                         }
7597                         _ => {}
7598                     }
7599                 }
7600                 &InstructionData::Load {
7601                     opcode: ref pattern5_0,
7602                     arg: pattern5_1,
7603                     flags: pattern5_2,
7604                     offset: pattern5_3,
7605                 } => {
7606                     if let &Opcode::Load = pattern5_0 {
7607                         // Rule at src/isa/x64/lower.isle line 2544.
7608                         let expr0_0 =
7609                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7610                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7611                         let expr2_0 = constructor_x64_movups(ctx, &expr1_0)?;
7612                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7613                         return Some(expr3_0);
7614                     }
7615                 }
7616                 _ => {}
7617             }
7618         }
7619         if pattern2_0 == F64X2 {
7620             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7621             match &pattern4_0 {
7622                 &InstructionData::Binary {
7623                     opcode: ref pattern5_0,
7624                     args: ref pattern5_1,
7625                 } => {
7626                     match pattern5_0 {
7627                         &Opcode::Fadd => {
7628                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7629                             // Rule at src/isa/x64/lower.isle line 2269.
7630                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7631                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7632                             let expr2_0 = constructor_x64_addpd(ctx, expr0_0, &expr1_0)?;
7633                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7634                             return Some(expr3_0);
7635                         }
7636                         &Opcode::Fsub => {
7637                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7638                             // Rule at src/isa/x64/lower.isle line 2280.
7639                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7640                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7641                             let expr2_0 = constructor_x64_subpd(ctx, expr0_0, &expr1_0)?;
7642                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7643                             return Some(expr3_0);
7644                         }
7645                         &Opcode::Fmul => {
7646                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7647                             // Rule at src/isa/x64/lower.isle line 2291.
7648                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7649                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7650                             let expr2_0 = constructor_x64_mulpd(ctx, expr0_0, &expr1_0)?;
7651                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7652                             return Some(expr3_0);
7653                         }
7654                         &Opcode::Fdiv => {
7655                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7656                             // Rule at src/isa/x64/lower.isle line 2302.
7657                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7658                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7659                             let expr2_0 = constructor_x64_divpd(ctx, expr0_0, &expr1_0)?;
7660                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7661                             return Some(expr3_0);
7662                         }
7663                         &Opcode::Fmin => {
7664                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7665                             // Rule at src/isa/x64/lower.isle line 2377.
7666                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7667                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7668                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
7669                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7670                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7671                             let expr5_0 = constructor_x64_minpd(ctx, expr3_0, expr4_0)?;
7672                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7673                             let expr7_0 = constructor_x64_orpd(ctx, expr2_0, &expr6_0)?;
7674                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7675                             let expr9_0 = FcmpImm::Unordered;
7676                             let expr10_0 = constructor_x64_cmppd(ctx, expr2_0, &expr8_0, &expr9_0)?;
7677                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
7678                             let expr12_0 = constructor_x64_orpd(ctx, expr7_0, &expr11_0)?;
7679                             let expr13_0: u32 = 13;
7680                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7681                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
7682                             let expr16_0 = constructor_x64_psrlq(ctx, expr10_0, &expr15_0)?;
7683                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
7684                             let expr18_0 = constructor_x64_andnpd(ctx, expr16_0, &expr17_0)?;
7685                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
7686                             return Some(expr19_0);
7687                         }
7688                         &Opcode::FminPseudo => {
7689                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7690                             // Rule at src/isa/x64/lower.isle line 2492.
7691                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7692                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7693                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
7694                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7695                             return Some(expr3_0);
7696                         }
7697                         &Opcode::Fmax => {
7698                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7699                             // Rule at src/isa/x64/lower.isle line 2440.
7700                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7701                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7702                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
7703                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7704                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7705                             let expr5_0 = constructor_x64_maxpd(ctx, expr3_0, expr4_0)?;
7706                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7707                             let expr7_0 = constructor_x64_xorpd(ctx, expr2_0, &expr6_0)?;
7708                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7709                             let expr9_0 = constructor_x64_orpd(ctx, expr2_0, &expr8_0)?;
7710                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7711                             let expr11_0 = constructor_x64_subpd(ctx, expr9_0, &expr10_0)?;
7712                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
7713                             let expr13_0 = FcmpImm::Unordered;
7714                             let expr14_0 =
7715                                 constructor_x64_cmppd(ctx, expr9_0, &expr12_0, &expr13_0)?;
7716                             let expr15_0: u32 = 13;
7717                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
7718                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
7719                             let expr18_0 = constructor_x64_psrlq(ctx, expr14_0, &expr17_0)?;
7720                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
7721                             let expr20_0 = constructor_x64_andnpd(ctx, expr18_0, &expr19_0)?;
7722                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
7723                             return Some(expr21_0);
7724                         }
7725                         &Opcode::FmaxPseudo => {
7726                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7727                             // Rule at src/isa/x64/lower.isle line 2503.
7728                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7729                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7730                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
7731                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7732                             return Some(expr3_0);
7733                         }
7734                         _ => {}
7735                     }
7736                 }
7737                 &InstructionData::Unary {
7738                     opcode: ref pattern5_0,
7739                     arg: pattern5_1,
7740                 } => {
7741                     match pattern5_0 {
7742                         &Opcode::Sqrt => {
7743                             // Rule at src/isa/x64/lower.isle line 2312.
7744                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7745                             let expr1_0 = constructor_x64_sqrtpd(ctx, expr0_0)?;
7746                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7747                             return Some(expr2_0);
7748                         }
7749                         &Opcode::Fabs => {
7750                             // Rule at src/isa/x64/lower.isle line 1244.
7751                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7752                             let expr1_0: Type = F64X2;
7753                             let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
7754                             let expr3_0: u32 = 1;
7755                             let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
7756                             let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
7757                             let expr6_0 = constructor_x64_psrlq(ctx, expr2_0, &expr5_0)?;
7758                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
7759                             let expr8_0 = constructor_x64_andpd(ctx, expr0_0, &expr7_0)?;
7760                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
7761                             return Some(expr9_0);
7762                         }
7763                         _ => {}
7764                     }
7765                 }
7766                 &InstructionData::Load {
7767                     opcode: ref pattern5_0,
7768                     arg: pattern5_1,
7769                     flags: pattern5_2,
7770                     offset: pattern5_3,
7771                 } => {
7772                     if let &Opcode::Load = pattern5_0 {
7773                         // Rule at src/isa/x64/lower.isle line 2546.
7774                         let expr0_0 =
7775                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7776                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7777                         let expr2_0 = constructor_x64_movupd(ctx, &expr1_0)?;
7778                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7779                         return Some(expr3_0);
7780                     }
7781                 }
7782                 _ => {}
7783             }
7784         }
7785         let pattern3_0 = C::inst_data(ctx, pattern0_0);
7786         match &pattern3_0 {
7787             &InstructionData::NullAry {
7788                 opcode: ref pattern4_0,
7789             } => {
7790                 if let &Opcode::Null = pattern4_0 {
7791                     // Rule at src/isa/x64/lower.isle line 56.
7792                     let expr0_0: u64 = 0;
7793                     let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?;
7794                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
7795                     return Some(expr2_0);
7796                 }
7797             }
7798             &InstructionData::Binary {
7799                 opcode: ref pattern4_0,
7800                 args: ref pattern4_1,
7801             } => {
7802                 if let &Opcode::BandNot = pattern4_0 {
7803                     let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
7804                     // Rule at src/isa/x64/lower.isle line 1205.
7805                     let expr0_0 = constructor_put_in_xmm(ctx, pattern6_1)?;
7806                     let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern6_0)?;
7807                     let expr2_0 = constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr1_0)?;
7808                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7809                     return Some(expr3_0);
7810                 }
7811             }
7812             &InstructionData::Ternary {
7813                 opcode: ref pattern4_0,
7814                 args: ref pattern4_1,
7815             } => {
7816                 if let &Opcode::Select = pattern4_0 {
7817                     let (pattern6_0, pattern6_1, pattern6_2) =
7818                         C::unpack_value_array_3(ctx, pattern4_1);
7819                     if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) {
7820                         let pattern8_0 = C::inst_data(ctx, pattern7_0);
7821                         match &pattern8_0 {
7822                             &InstructionData::FloatCompare {
7823                                 opcode: ref pattern9_0,
7824                                 args: ref pattern9_1,
7825                                 cond: ref pattern9_2,
7826                             } => {
7827                                 if let &Opcode::Fcmp = pattern9_0 {
7828                                     let (pattern11_0, pattern11_1) =
7829                                         C::unpack_value_array_2(ctx, pattern9_1);
7830                                     match pattern9_2 {
7831                                         &FloatCC::Equal => {
7832                                             // Rule at src/isa/x64/lower.isle line 1740.
7833                                             let expr0_0 = constructor_x64_ucomis(
7834                                                 ctx,
7835                                                 pattern11_0,
7836                                                 pattern11_1,
7837                                             )?;
7838                                             let expr1_0 = CC::NZ;
7839                                             let expr2_0 = CC::P;
7840                                             let expr3_0 = constructor_cmove_or_from_values(
7841                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_2,
7842                                                 pattern6_1,
7843                                             )?;
7844                                             let expr4_0 =
7845                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
7846                                             let expr5_0 = C::output(ctx, expr4_0);
7847                                             return Some(expr5_0);
7848                                         }
7849                                         &FloatCC::GreaterThan => {
7850                                             // Rule at src/isa/x64/lower.isle line 1692.
7851                                             let expr0_0 = constructor_x64_ucomis(
7852                                                 ctx,
7853                                                 pattern11_1,
7854                                                 pattern11_0,
7855                                             )?;
7856                                             let expr1_0 = CC::NBE;
7857                                             let expr2_0 = constructor_cmove_from_values(
7858                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7859                                             )?;
7860                                             let expr3_0 =
7861                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7862                                             let expr4_0 = C::output(ctx, expr3_0);
7863                                             return Some(expr4_0);
7864                                         }
7865                                         &FloatCC::GreaterThanOrEqual => {
7866                                             // Rule at src/isa/x64/lower.isle line 1695.
7867                                             let expr0_0 = constructor_x64_ucomis(
7868                                                 ctx,
7869                                                 pattern11_1,
7870                                                 pattern11_0,
7871                                             )?;
7872                                             let expr1_0 = CC::NB;
7873                                             let expr2_0 = constructor_cmove_from_values(
7874                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7875                                             )?;
7876                                             let expr3_0 =
7877                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7878                                             let expr4_0 = C::output(ctx, expr3_0);
7879                                             return Some(expr4_0);
7880                                         }
7881                                         &FloatCC::LessThan => {
7882                                             // Rule at src/isa/x64/lower.isle line 1715.
7883                                             let expr0_0 = constructor_x64_ucomis(
7884                                                 ctx,
7885                                                 pattern11_0,
7886                                                 pattern11_1,
7887                                             )?;
7888                                             let expr1_0 = CC::NBE;
7889                                             let expr2_0 = constructor_cmove_from_values(
7890                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7891                                             )?;
7892                                             let expr3_0 =
7893                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7894                                             let expr4_0 = C::output(ctx, expr3_0);
7895                                             return Some(expr4_0);
7896                                         }
7897                                         &FloatCC::LessThanOrEqual => {
7898                                             // Rule at src/isa/x64/lower.isle line 1718.
7899                                             let expr0_0 = constructor_x64_ucomis(
7900                                                 ctx,
7901                                                 pattern11_0,
7902                                                 pattern11_1,
7903                                             )?;
7904                                             let expr1_0 = CC::NB;
7905                                             let expr2_0 = constructor_cmove_from_values(
7906                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7907                                             )?;
7908                                             let expr3_0 =
7909                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7910                                             let expr4_0 = C::output(ctx, expr3_0);
7911                                             return Some(expr4_0);
7912                                         }
7913                                         &FloatCC::NotEqual => {
7914                                             // Rule at src/isa/x64/lower.isle line 1743.
7915                                             let expr0_0 = constructor_x64_ucomis(
7916                                                 ctx,
7917                                                 pattern11_0,
7918                                                 pattern11_1,
7919                                             )?;
7920                                             let expr1_0 = CC::NZ;
7921                                             let expr2_0 = CC::P;
7922                                             let expr3_0 = constructor_cmove_or_from_values(
7923                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_1,
7924                                                 pattern6_2,
7925                                             )?;
7926                                             let expr4_0 =
7927                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
7928                                             let expr5_0 = C::output(ctx, expr4_0);
7929                                             return Some(expr5_0);
7930                                         }
7931                                         &FloatCC::Ordered => {
7932                                             // Rule at src/isa/x64/lower.isle line 1686.
7933                                             let expr0_0 = constructor_x64_ucomis(
7934                                                 ctx,
7935                                                 pattern11_1,
7936                                                 pattern11_0,
7937                                             )?;
7938                                             let expr1_0 = CC::NP;
7939                                             let expr2_0 = constructor_cmove_from_values(
7940                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7941                                             )?;
7942                                             let expr3_0 =
7943                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7944                                             let expr4_0 = C::output(ctx, expr3_0);
7945                                             return Some(expr4_0);
7946                                         }
7947                                         &FloatCC::Unordered => {
7948                                             // Rule at src/isa/x64/lower.isle line 1689.
7949                                             let expr0_0 = constructor_x64_ucomis(
7950                                                 ctx,
7951                                                 pattern11_1,
7952                                                 pattern11_0,
7953                                             )?;
7954                                             let expr1_0 = CC::P;
7955                                             let expr2_0 = constructor_cmove_from_values(
7956                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7957                                             )?;
7958                                             let expr3_0 =
7959                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7960                                             let expr4_0 = C::output(ctx, expr3_0);
7961                                             return Some(expr4_0);
7962                                         }
7963                                         &FloatCC::UnorderedOrGreaterThan => {
7964                                             // Rule at src/isa/x64/lower.isle line 1721.
7965                                             let expr0_0 = constructor_x64_ucomis(
7966                                                 ctx,
7967                                                 pattern11_0,
7968                                                 pattern11_1,
7969                                             )?;
7970                                             let expr1_0 = CC::B;
7971                                             let expr2_0 = constructor_cmove_from_values(
7972                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7973                                             )?;
7974                                             let expr3_0 =
7975                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7976                                             let expr4_0 = C::output(ctx, expr3_0);
7977                                             return Some(expr4_0);
7978                                         }
7979                                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
7980                                             // Rule at src/isa/x64/lower.isle line 1724.
7981                                             let expr0_0 = constructor_x64_ucomis(
7982                                                 ctx,
7983                                                 pattern11_0,
7984                                                 pattern11_1,
7985                                             )?;
7986                                             let expr1_0 = CC::BE;
7987                                             let expr2_0 = constructor_cmove_from_values(
7988                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7989                                             )?;
7990                                             let expr3_0 =
7991                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7992                                             let expr4_0 = C::output(ctx, expr3_0);
7993                                             return Some(expr4_0);
7994                                         }
7995                                         &FloatCC::UnorderedOrLessThan => {
7996                                             // Rule at src/isa/x64/lower.isle line 1698.
7997                                             let expr0_0 = constructor_x64_ucomis(
7998                                                 ctx,
7999                                                 pattern11_1,
8000                                                 pattern11_0,
8001                                             )?;
8002                                             let expr1_0 = CC::B;
8003                                             let expr2_0 = constructor_cmove_from_values(
8004                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8005                                             )?;
8006                                             let expr3_0 =
8007                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8008                                             let expr4_0 = C::output(ctx, expr3_0);
8009                                             return Some(expr4_0);
8010                                         }
8011                                         &FloatCC::UnorderedOrLessThanOrEqual => {
8012                                             // Rule at src/isa/x64/lower.isle line 1701.
8013                                             let expr0_0 = constructor_x64_ucomis(
8014                                                 ctx,
8015                                                 pattern11_1,
8016                                                 pattern11_0,
8017                                             )?;
8018                                             let expr1_0 = CC::BE;
8019                                             let expr2_0 = constructor_cmove_from_values(
8020                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8021                                             )?;
8022                                             let expr3_0 =
8023                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8024                                             let expr4_0 = C::output(ctx, expr3_0);
8025                                             return Some(expr4_0);
8026                                         }
8027                                         _ => {}
8028                                     }
8029                                 }
8030                             }
8031                             &InstructionData::IntCompare {
8032                                 opcode: ref pattern9_0,
8033                                 args: ref pattern9_1,
8034                                 cond: ref pattern9_2,
8035                             } => {
8036                                 if let &Opcode::Icmp = pattern9_0 {
8037                                     let (pattern11_0, pattern11_1) =
8038                                         C::unpack_value_array_2(ctx, pattern9_1);
8039                                     let pattern12_0 = C::value_type(ctx, pattern11_0);
8040                                     if let Some(pattern13_0) = C::fits_in_64(ctx, pattern12_0) {
8041                                         // Rule at src/isa/x64/lower.isle line 1751.
8042                                         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern13_0);
8043                                         let expr1_0 =
8044                                             constructor_put_in_gpr_mem_imm(ctx, pattern11_1)?;
8045                                         let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
8046                                         let expr3_0 =
8047                                             constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?;
8048                                         let expr4_0 = C::intcc_to_cc(ctx, pattern9_2);
8049                                         let expr5_0 = constructor_cmove_from_values(
8050                                             ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2,
8051                                         )?;
8052                                         let expr6_0 =
8053                                             constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
8054                                         let expr7_0 = C::output(ctx, expr6_0);
8055                                         return Some(expr7_0);
8056                                     }
8057                                 }
8058                             }
8059                             _ => {}
8060                         }
8061                     }
8062                     let pattern7_0 = C::value_type(ctx, pattern6_0);
8063                     if pattern7_0 == B1 {
8064                         // Rule at src/isa/x64/lower.isle line 1758.
8065                         let expr0_0: Type = B1;
8066                         let expr1_0 = C::raw_operand_size_of_type(ctx, expr0_0);
8067                         let expr2_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
8068                         let expr3_0: u32 = 1;
8069                         let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
8070                         let expr5_0 = C::gpr_mem_imm_new(ctx, &expr4_0);
8071                         let expr6_0 = constructor_x64_test(ctx, &expr1_0, &expr5_0, expr2_0)?;
8072                         let expr7_0 = CC::NZ;
8073                         let expr8_0 = constructor_cmove_from_values(
8074                             ctx, pattern2_0, &expr7_0, pattern6_1, pattern6_2,
8075                         )?;
8076                         let expr9_0 = constructor_with_flags(ctx, &expr6_0, &expr8_0)?;
8077                         let expr10_0 = C::output(ctx, expr9_0);
8078                         return Some(expr10_0);
8079                     }
8080                     if let Some(pattern8_0) = C::fits_in_64(ctx, pattern7_0) {
8081                         // Rule at src/isa/x64/lower.isle line 1765.
8082                         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern8_0);
8083                         let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
8084                         let expr2_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
8085                         let expr3_0 = constructor_x64_test(ctx, &expr0_0, &expr2_0, expr1_0)?;
8086                         let expr4_0 = CC::NZ;
8087                         let expr5_0 = constructor_cmove_from_values(
8088                             ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2,
8089                         )?;
8090                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
8091                         let expr7_0 = C::output(ctx, expr6_0);
8092                         return Some(expr7_0);
8093                     }
8094                 }
8095             }
8096             &InstructionData::Unary {
8097                 opcode: ref pattern4_0,
8098                 arg: pattern4_1,
8099             } => {
8100                 match pattern4_0 {
8101                     &Opcode::Breduce => {
8102                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8103                         if pattern6_0 == pattern2_0 {
8104                             // Rule at src/isa/x64/lower.isle line 2226.
8105                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8106                             return Some(expr0_0);
8107                         }
8108                     }
8109                     &Opcode::Bextend => {
8110                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8111                         // Rule at src/isa/x64/lower.isle line 2207.
8112                         let expr0_0 =
8113                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
8114                         return Some(expr0_0);
8115                     }
8116                     &Opcode::Ireduce => {
8117                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8118                         if pattern6_0 == pattern2_0 {
8119                             // Rule at src/isa/x64/lower.isle line 2215.
8120                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8121                             return Some(expr0_0);
8122                         }
8123                     }
8124                     &Opcode::Uextend => {
8125                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8126                         if pattern6_0 == pattern2_0 {
8127                             // Rule at src/isa/x64/lower.isle line 2108.
8128                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8129                             return Some(expr0_0);
8130                         }
8131                     }
8132                     &Opcode::Sextend => {
8133                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8134                         // Rule at src/isa/x64/lower.isle line 2201.
8135                         let expr0_0 =
8136                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
8137                         return Some(expr0_0);
8138                     }
8139                     _ => {}
8140                 }
8141             }
8142             _ => {}
8143         }
8144         if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
8145             if let Some(()) = C::avx512dq_enabled(ctx, pattern2_0) {
8146                 if let Some((pattern5_0, pattern5_1)) = C::multi_lane(ctx, pattern2_0) {
8147                     if pattern5_0 == 64 {
8148                         if pattern5_1 == 2 {
8149                             let pattern8_0 = C::inst_data(ctx, pattern0_0);
8150                             if let &InstructionData::Binary {
8151                                 opcode: ref pattern9_0,
8152                                 args: ref pattern9_1,
8153                             } = &pattern8_0
8154                             {
8155                                 if let &Opcode::Imul = pattern9_0 {
8156                                     let (pattern11_0, pattern11_1) =
8157                                         C::unpack_value_array_2(ctx, pattern9_1);
8158                                     // Rule at src/isa/x64/lower.isle line 992.
8159                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern11_0)?;
8160                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern11_1)?;
8161                                     let expr2_0 = constructor_x64_vpmullq(ctx, &expr0_0, expr1_0)?;
8162                                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8163                                     return Some(expr3_0);
8164                                 }
8165                             }
8166                         }
8167                     }
8168                 }
8169             }
8170             if let Some(()) = C::avx512f_enabled(ctx, pattern2_0) {
8171                 if pattern2_0 == I64X2 {
8172                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8173                     if let &InstructionData::Unary {
8174                         opcode: ref pattern7_0,
8175                         arg: pattern7_1,
8176                     } = &pattern6_0
8177                     {
8178                         if let &Opcode::Iabs = pattern7_0 {
8179                             // Rule at src/isa/x64/lower.isle line 1220.
8180                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8181                             let expr1_0 = constructor_x64_vpabsq(ctx, &expr0_0)?;
8182                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8183                             return Some(expr2_0);
8184                         }
8185                     }
8186                 }
8187             }
8188         }
8189         if let Some((pattern3_0, pattern3_1)) = C::multi_lane(ctx, pattern2_0) {
8190             if pattern3_0 == 8 {
8191                 if pattern3_1 == 16 {
8192                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8193                     if let &InstructionData::Binary {
8194                         opcode: ref pattern7_0,
8195                         args: ref pattern7_1,
8196                     } = &pattern6_0
8197                     {
8198                         match pattern7_0 {
8199                             &Opcode::AvgRound => {
8200                                 let (pattern9_0, pattern9_1) =
8201                                     C::unpack_value_array_2(ctx, pattern7_1);
8202                                 // Rule at src/isa/x64/lower.isle line 903.
8203                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8204                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8205                                 let expr2_0 = constructor_x64_pavgb(ctx, expr0_0, &expr1_0)?;
8206                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8207                                 return Some(expr3_0);
8208                             }
8209                             &Opcode::UaddSat => {
8210                                 let (pattern9_0, pattern9_1) =
8211                                     C::unpack_value_array_2(ctx, pattern7_1);
8212                                 // Rule at src/isa/x64/lower.isle line 136.
8213                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8214                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8215                                 let expr2_0 = constructor_x64_paddusb(ctx, expr0_0, &expr1_0)?;
8216                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8217                                 return Some(expr3_0);
8218                             }
8219                             &Opcode::SaddSat => {
8220                                 let (pattern9_0, pattern9_1) =
8221                                     C::unpack_value_array_2(ctx, pattern7_1);
8222                                 // Rule at src/isa/x64/lower.isle line 126.
8223                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8224                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8225                                 let expr2_0 = constructor_x64_paddsb(ctx, expr0_0, &expr1_0)?;
8226                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8227                                 return Some(expr3_0);
8228                             }
8229                             &Opcode::UsubSat => {
8230                                 let (pattern9_0, pattern9_1) =
8231                                     C::unpack_value_array_2(ctx, pattern7_1);
8232                                 // Rule at src/isa/x64/lower.isle line 282.
8233                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8234                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8235                                 let expr2_0 = constructor_x64_psubusb(ctx, expr0_0, &expr1_0)?;
8236                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8237                                 return Some(expr3_0);
8238                             }
8239                             &Opcode::SsubSat => {
8240                                 let (pattern9_0, pattern9_1) =
8241                                     C::unpack_value_array_2(ctx, pattern7_1);
8242                                 // Rule at src/isa/x64/lower.isle line 272.
8243                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8244                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8245                                 let expr2_0 = constructor_x64_psubsb(ctx, expr0_0, &expr1_0)?;
8246                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8247                                 return Some(expr3_0);
8248                             }
8249                             &Opcode::Iadd => {
8250                                 let (pattern9_0, pattern9_1) =
8251                                     C::unpack_value_array_2(ctx, pattern7_1);
8252                                 // Rule at src/isa/x64/lower.isle line 94.
8253                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8254                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8255                                 let expr2_0 = constructor_x64_paddb(ctx, expr0_0, &expr1_0)?;
8256                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8257                                 return Some(expr3_0);
8258                             }
8259                             &Opcode::Isub => {
8260                                 let (pattern9_0, pattern9_1) =
8261                                     C::unpack_value_array_2(ctx, pattern7_1);
8262                                 // Rule at src/isa/x64/lower.isle line 240.
8263                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8264                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8265                                 let expr2_0 = constructor_x64_psubb(ctx, expr0_0, &expr1_0)?;
8266                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8267                                 return Some(expr3_0);
8268                             }
8269                             _ => {}
8270                         }
8271                     }
8272                 }
8273             }
8274             if pattern3_0 == 16 {
8275                 if pattern3_1 == 8 {
8276                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8277                     if let &InstructionData::Binary {
8278                         opcode: ref pattern7_0,
8279                         args: ref pattern7_1,
8280                     } = &pattern6_0
8281                     {
8282                         match pattern7_0 {
8283                             &Opcode::AvgRound => {
8284                                 let (pattern9_0, pattern9_1) =
8285                                     C::unpack_value_array_2(ctx, pattern7_1);
8286                                 // Rule at src/isa/x64/lower.isle line 907.
8287                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8288                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8289                                 let expr2_0 = constructor_x64_pavgw(ctx, expr0_0, &expr1_0)?;
8290                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8291                                 return Some(expr3_0);
8292                             }
8293                             &Opcode::UaddSat => {
8294                                 let (pattern9_0, pattern9_1) =
8295                                     C::unpack_value_array_2(ctx, pattern7_1);
8296                                 // Rule at src/isa/x64/lower.isle line 140.
8297                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8298                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8299                                 let expr2_0 = constructor_x64_paddusw(ctx, expr0_0, &expr1_0)?;
8300                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8301                                 return Some(expr3_0);
8302                             }
8303                             &Opcode::SaddSat => {
8304                                 let (pattern9_0, pattern9_1) =
8305                                     C::unpack_value_array_2(ctx, pattern7_1);
8306                                 // Rule at src/isa/x64/lower.isle line 130.
8307                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8308                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8309                                 let expr2_0 = constructor_x64_paddsw(ctx, expr0_0, &expr1_0)?;
8310                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8311                                 return Some(expr3_0);
8312                             }
8313                             &Opcode::UsubSat => {
8314                                 let (pattern9_0, pattern9_1) =
8315                                     C::unpack_value_array_2(ctx, pattern7_1);
8316                                 // Rule at src/isa/x64/lower.isle line 286.
8317                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8318                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8319                                 let expr2_0 = constructor_x64_psubusw(ctx, expr0_0, &expr1_0)?;
8320                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8321                                 return Some(expr3_0);
8322                             }
8323                             &Opcode::SsubSat => {
8324                                 let (pattern9_0, pattern9_1) =
8325                                     C::unpack_value_array_2(ctx, pattern7_1);
8326                                 // Rule at src/isa/x64/lower.isle line 276.
8327                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8328                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8329                                 let expr2_0 = constructor_x64_psubsw(ctx, expr0_0, &expr1_0)?;
8330                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8331                                 return Some(expr3_0);
8332                             }
8333                             &Opcode::Iadd => {
8334                                 let (pattern9_0, pattern9_1) =
8335                                     C::unpack_value_array_2(ctx, pattern7_1);
8336                                 // Rule at src/isa/x64/lower.isle line 98.
8337                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8338                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8339                                 let expr2_0 = constructor_x64_paddw(ctx, expr0_0, &expr1_0)?;
8340                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8341                                 return Some(expr3_0);
8342                             }
8343                             &Opcode::Isub => {
8344                                 let (pattern9_0, pattern9_1) =
8345                                     C::unpack_value_array_2(ctx, pattern7_1);
8346                                 // Rule at src/isa/x64/lower.isle line 244.
8347                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8348                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8349                                 let expr2_0 = constructor_x64_psubw(ctx, expr0_0, &expr1_0)?;
8350                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8351                                 return Some(expr3_0);
8352                             }
8353                             &Opcode::Imul => {
8354                                 let (pattern9_0, pattern9_1) =
8355                                     C::unpack_value_array_2(ctx, pattern7_1);
8356                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
8357                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
8358                                     if let &InstructionData::Unary {
8359                                         opcode: ref pattern12_0,
8360                                         arg: pattern12_1,
8361                                     } = &pattern11_0
8362                                     {
8363                                         match pattern12_0 {
8364                                             &Opcode::SwidenLow => {
8365                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8366                                                 if let Some((pattern15_0, pattern15_1)) =
8367                                                     C::multi_lane(ctx, pattern14_0)
8368                                                 {
8369                                                     if pattern15_0 == 8 {
8370                                                         if pattern15_1 == 16 {
8371                                                             if let Some(pattern18_0) =
8372                                                                 C::def_inst(ctx, pattern9_1)
8373                                                             {
8374                                                                 let pattern19_0 =
8375                                                                     C::inst_data(ctx, pattern18_0);
8376                                                                 if let &InstructionData::Unary {
8377                                                                     opcode: ref pattern20_0,
8378                                                                     arg: pattern20_1,
8379                                                                 } = &pattern19_0
8380                                                                 {
8381                                                                     if let &Opcode::SwidenLow =
8382                                                                         pattern20_0
8383                                                                     {
8384                                                                         let pattern22_0 =
8385                                                                             C::value_type(
8386                                                                                 ctx,
8387                                                                                 pattern20_1,
8388                                                                             );
8389                                                                         if let Some((
8390                                                                             pattern23_0,
8391                                                                             pattern23_1,
8392                                                                         )) = C::multi_lane(
8393                                                                             ctx,
8394                                                                             pattern22_0,
8395                                                                         ) {
8396                                                                             if pattern23_0 == 8 {
8397                                                                                 if pattern23_1 == 16
8398                                                                                 {
8399                                                                                     // Rule at src/isa/x64/lower.isle line 1080.
8400                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8401                                                                                     let expr1_0 = constructor_x64_pmovsxbw(ctx, &expr0_0)?;
8402                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8403                                                                                     let expr3_0 = constructor_x64_pmovsxbw(ctx, &expr2_0)?;
8404                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
8405                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
8406                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8407                                                                                     return Some(
8408                                                                                         expr6_0,
8409                                                                                     );
8410                                                                                 }
8411                                                                             }
8412                                                                         }
8413                                                                     }
8414                                                                 }
8415                                                             }
8416                                                         }
8417                                                     }
8418                                                 }
8419                                             }
8420                                             &Opcode::SwidenHigh => {
8421                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8422                                                 if let Some((pattern15_0, pattern15_1)) =
8423                                                     C::multi_lane(ctx, pattern14_0)
8424                                                 {
8425                                                     if pattern15_0 == 8 {
8426                                                         if pattern15_1 == 16 {
8427                                                             if let Some(pattern18_0) =
8428                                                                 C::def_inst(ctx, pattern9_1)
8429                                                             {
8430                                                                 let pattern19_0 =
8431                                                                     C::inst_data(ctx, pattern18_0);
8432                                                                 if let &InstructionData::Unary {
8433                                                                     opcode: ref pattern20_0,
8434                                                                     arg: pattern20_1,
8435                                                                 } = &pattern19_0
8436                                                                 {
8437                                                                     if let &Opcode::SwidenHigh =
8438                                                                         pattern20_0
8439                                                                     {
8440                                                                         let pattern22_0 =
8441                                                                             C::value_type(
8442                                                                                 ctx,
8443                                                                                 pattern20_1,
8444                                                                             );
8445                                                                         if let Some((
8446                                                                             pattern23_0,
8447                                                                             pattern23_1,
8448                                                                         )) = C::multi_lane(
8449                                                                             ctx,
8450                                                                             pattern22_0,
8451                                                                         ) {
8452                                                                             if pattern23_0 == 8 {
8453                                                                                 if pattern23_1 == 16
8454                                                                                 {
8455                                                                                     // Rule at src/isa/x64/lower.isle line 1040.
8456                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8457                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8458                                                                                     let expr2_0: u8 = 8;
8459                                                                                     let expr3_0 = OperandSize::Size32;
8460                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
8461                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
8462                                                                                     let expr6_0 = constructor_x64_pmovsxbw(ctx, &expr5_0)?;
8463                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8464                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8465                                                                                     let expr9_0: u8 = 8;
8466                                                                                     let expr10_0 = OperandSize::Size32;
8467                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
8468                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8469                                                                                     let expr13_0 = constructor_x64_pmovsxbw(ctx, &expr12_0)?;
8470                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
8471                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
8472                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
8473                                                                                     return Some(
8474                                                                                         expr16_0,
8475                                                                                     );
8476                                                                                 }
8477                                                                             }
8478                                                                         }
8479                                                                     }
8480                                                                 }
8481                                                             }
8482                                                         }
8483                                                     }
8484                                                 }
8485                                             }
8486                                             &Opcode::UwidenLow => {
8487                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8488                                                 if let Some((pattern15_0, pattern15_1)) =
8489                                                     C::multi_lane(ctx, pattern14_0)
8490                                                 {
8491                                                     if pattern15_0 == 8 {
8492                                                         if pattern15_1 == 16 {
8493                                                             if let Some(pattern18_0) =
8494                                                                 C::def_inst(ctx, pattern9_1)
8495                                                             {
8496                                                                 let pattern19_0 =
8497                                                                     C::inst_data(ctx, pattern18_0);
8498                                                                 if let &InstructionData::Unary {
8499                                                                     opcode: ref pattern20_0,
8500                                                                     arg: pattern20_1,
8501                                                                 } = &pattern19_0
8502                                                                 {
8503                                                                     if let &Opcode::UwidenLow =
8504                                                                         pattern20_0
8505                                                                     {
8506                                                                         let pattern22_0 =
8507                                                                             C::value_type(
8508                                                                                 ctx,
8509                                                                                 pattern20_1,
8510                                                                             );
8511                                                                         if let Some((
8512                                                                             pattern23_0,
8513                                                                             pattern23_1,
8514                                                                         )) = C::multi_lane(
8515                                                                             ctx,
8516                                                                             pattern22_0,
8517                                                                         ) {
8518                                                                             if pattern23_0 == 8 {
8519                                                                                 if pattern23_1 == 16
8520                                                                                 {
8521                                                                                     // Rule at src/isa/x64/lower.isle line 1156.
8522                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8523                                                                                     let expr1_0 = constructor_x64_pmovzxbw(ctx, &expr0_0)?;
8524                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8525                                                                                     let expr3_0 = constructor_x64_pmovzxbw(ctx, &expr2_0)?;
8526                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
8527                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
8528                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8529                                                                                     return Some(
8530                                                                                         expr6_0,
8531                                                                                     );
8532                                                                                 }
8533                                                                             }
8534                                                                         }
8535                                                                     }
8536                                                                 }
8537                                                             }
8538                                                         }
8539                                                     }
8540                                                 }
8541                                             }
8542                                             &Opcode::UwidenHigh => {
8543                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8544                                                 if let Some((pattern15_0, pattern15_1)) =
8545                                                     C::multi_lane(ctx, pattern14_0)
8546                                                 {
8547                                                     if pattern15_0 == 8 {
8548                                                         if pattern15_1 == 16 {
8549                                                             if let Some(pattern18_0) =
8550                                                                 C::def_inst(ctx, pattern9_1)
8551                                                             {
8552                                                                 let pattern19_0 =
8553                                                                     C::inst_data(ctx, pattern18_0);
8554                                                                 if let &InstructionData::Unary {
8555                                                                     opcode: ref pattern20_0,
8556                                                                     arg: pattern20_1,
8557                                                                 } = &pattern19_0
8558                                                                 {
8559                                                                     if let &Opcode::UwidenHigh =
8560                                                                         pattern20_0
8561                                                                     {
8562                                                                         let pattern22_0 =
8563                                                                             C::value_type(
8564                                                                                 ctx,
8565                                                                                 pattern20_1,
8566                                                                             );
8567                                                                         if let Some((
8568                                                                             pattern23_0,
8569                                                                             pattern23_1,
8570                                                                         )) = C::multi_lane(
8571                                                                             ctx,
8572                                                                             pattern22_0,
8573                                                                         ) {
8574                                                                             if pattern23_0 == 8 {
8575                                                                                 if pattern23_1 == 16
8576                                                                                 {
8577                                                                                     // Rule at src/isa/x64/lower.isle line 1116.
8578                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8579                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8580                                                                                     let expr2_0: u8 = 8;
8581                                                                                     let expr3_0 = OperandSize::Size32;
8582                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
8583                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
8584                                                                                     let expr6_0 = constructor_x64_pmovzxbw(ctx, &expr5_0)?;
8585                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8586                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8587                                                                                     let expr9_0: u8 = 8;
8588                                                                                     let expr10_0 = OperandSize::Size32;
8589                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
8590                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8591                                                                                     let expr13_0 = constructor_x64_pmovzxbw(ctx, &expr12_0)?;
8592                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
8593                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
8594                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
8595                                                                                     return Some(
8596                                                                                         expr16_0,
8597                                                                                     );
8598                                                                                 }
8599                                                                             }
8600                                                                         }
8601                                                                     }
8602                                                                 }
8603                                                             }
8604                                                         }
8605                                                     }
8606                                                 }
8607                                             }
8608                                             _ => {}
8609                                         }
8610                                     }
8611                                 }
8612                                 // Rule at src/isa/x64/lower.isle line 984.
8613                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8614                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8615                                 let expr2_0 = constructor_x64_pmullw(ctx, expr0_0, &expr1_0)?;
8616                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8617                                 return Some(expr3_0);
8618                             }
8619                             _ => {}
8620                         }
8621                     }
8622                 }
8623             }
8624             if pattern3_0 == 32 {
8625                 if pattern3_1 == 4 {
8626                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8627                     if let &InstructionData::Binary {
8628                         opcode: ref pattern7_0,
8629                         args: ref pattern7_1,
8630                     } = &pattern6_0
8631                     {
8632                         match pattern7_0 {
8633                             &Opcode::Iadd => {
8634                                 let (pattern9_0, pattern9_1) =
8635                                     C::unpack_value_array_2(ctx, pattern7_1);
8636                                 // Rule at src/isa/x64/lower.isle line 102.
8637                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8638                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8639                                 let expr2_0 = constructor_x64_paddd(ctx, expr0_0, &expr1_0)?;
8640                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8641                                 return Some(expr3_0);
8642                             }
8643                             &Opcode::Isub => {
8644                                 let (pattern9_0, pattern9_1) =
8645                                     C::unpack_value_array_2(ctx, pattern7_1);
8646                                 // Rule at src/isa/x64/lower.isle line 248.
8647                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8648                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8649                                 let expr2_0 = constructor_x64_psubd(ctx, expr0_0, &expr1_0)?;
8650                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8651                                 return Some(expr3_0);
8652                             }
8653                             &Opcode::Imul => {
8654                                 let (pattern9_0, pattern9_1) =
8655                                     C::unpack_value_array_2(ctx, pattern7_1);
8656                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
8657                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
8658                                     if let &InstructionData::Unary {
8659                                         opcode: ref pattern12_0,
8660                                         arg: pattern12_1,
8661                                     } = &pattern11_0
8662                                     {
8663                                         match pattern12_0 {
8664                                             &Opcode::SwidenLow => {
8665                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8666                                                 if let Some((pattern15_0, pattern15_1)) =
8667                                                     C::multi_lane(ctx, pattern14_0)
8668                                                 {
8669                                                     if pattern15_0 == 16 {
8670                                                         if pattern15_1 == 8 {
8671                                                             if let Some(pattern18_0) =
8672                                                                 C::def_inst(ctx, pattern9_1)
8673                                                             {
8674                                                                 let pattern19_0 =
8675                                                                     C::inst_data(ctx, pattern18_0);
8676                                                                 if let &InstructionData::Unary {
8677                                                                     opcode: ref pattern20_0,
8678                                                                     arg: pattern20_1,
8679                                                                 } = &pattern19_0
8680                                                                 {
8681                                                                     if let &Opcode::SwidenLow =
8682                                                                         pattern20_0
8683                                                                     {
8684                                                                         let pattern22_0 =
8685                                                                             C::value_type(
8686                                                                                 ctx,
8687                                                                                 pattern20_1,
8688                                                                             );
8689                                                                         if let Some((
8690                                                                             pattern23_0,
8691                                                                             pattern23_1,
8692                                                                         )) = C::multi_lane(
8693                                                                             ctx,
8694                                                                             pattern22_0,
8695                                                                         ) {
8696                                                                             if pattern23_0 == 16 {
8697                                                                                 if pattern23_1 == 8
8698                                                                                 {
8699                                                                                     // Rule at src/isa/x64/lower.isle line 1090.
8700                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8701                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8702                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8703                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8704                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8705                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
8706                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8707                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
8708                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8709                                                                                     return Some(
8710                                                                                         expr8_0,
8711                                                                                     );
8712                                                                                 }
8713                                                                             }
8714                                                                         }
8715                                                                     }
8716                                                                 }
8717                                                             }
8718                                                         }
8719                                                     }
8720                                                 }
8721                                             }
8722                                             &Opcode::SwidenHigh => {
8723                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8724                                                 if let Some((pattern15_0, pattern15_1)) =
8725                                                     C::multi_lane(ctx, pattern14_0)
8726                                                 {
8727                                                     if pattern15_0 == 16 {
8728                                                         if pattern15_1 == 8 {
8729                                                             if let Some(pattern18_0) =
8730                                                                 C::def_inst(ctx, pattern9_1)
8731                                                             {
8732                                                                 let pattern19_0 =
8733                                                                     C::inst_data(ctx, pattern18_0);
8734                                                                 if let &InstructionData::Unary {
8735                                                                     opcode: ref pattern20_0,
8736                                                                     arg: pattern20_1,
8737                                                                 } = &pattern19_0
8738                                                                 {
8739                                                                     if let &Opcode::SwidenHigh =
8740                                                                         pattern20_0
8741                                                                     {
8742                                                                         let pattern22_0 =
8743                                                                             C::value_type(
8744                                                                                 ctx,
8745                                                                                 pattern20_1,
8746                                                                             );
8747                                                                         if let Some((
8748                                                                             pattern23_0,
8749                                                                             pattern23_1,
8750                                                                         )) = C::multi_lane(
8751                                                                             ctx,
8752                                                                             pattern22_0,
8753                                                                         ) {
8754                                                                             if pattern23_0 == 16 {
8755                                                                                 if pattern23_1 == 8
8756                                                                                 {
8757                                                                                     // Rule at src/isa/x64/lower.isle line 1054.
8758                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8759                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8760                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8761                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8762                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8763                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
8764                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8765                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
8766                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8767                                                                                     return Some(
8768                                                                                         expr8_0,
8769                                                                                     );
8770                                                                                 }
8771                                                                             }
8772                                                                         }
8773                                                                     }
8774                                                                 }
8775                                                             }
8776                                                         }
8777                                                     }
8778                                                 }
8779                                             }
8780                                             &Opcode::UwidenLow => {
8781                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8782                                                 if let Some((pattern15_0, pattern15_1)) =
8783                                                     C::multi_lane(ctx, pattern14_0)
8784                                                 {
8785                                                     if pattern15_0 == 16 {
8786                                                         if pattern15_1 == 8 {
8787                                                             if let Some(pattern18_0) =
8788                                                                 C::def_inst(ctx, pattern9_1)
8789                                                             {
8790                                                                 let pattern19_0 =
8791                                                                     C::inst_data(ctx, pattern18_0);
8792                                                                 if let &InstructionData::Unary {
8793                                                                     opcode: ref pattern20_0,
8794                                                                     arg: pattern20_1,
8795                                                                 } = &pattern19_0
8796                                                                 {
8797                                                                     if let &Opcode::UwidenLow =
8798                                                                         pattern20_0
8799                                                                     {
8800                                                                         let pattern22_0 =
8801                                                                             C::value_type(
8802                                                                                 ctx,
8803                                                                                 pattern20_1,
8804                                                                             );
8805                                                                         if let Some((
8806                                                                             pattern23_0,
8807                                                                             pattern23_1,
8808                                                                         )) = C::multi_lane(
8809                                                                             ctx,
8810                                                                             pattern22_0,
8811                                                                         ) {
8812                                                                             if pattern23_0 == 16 {
8813                                                                                 if pattern23_1 == 8
8814                                                                                 {
8815                                                                                     // Rule at src/isa/x64/lower.isle line 1166.
8816                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8817                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8818                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8819                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8820                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8821                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
8822                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8823                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
8824                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8825                                                                                     return Some(
8826                                                                                         expr8_0,
8827                                                                                     );
8828                                                                                 }
8829                                                                             }
8830                                                                         }
8831                                                                     }
8832                                                                 }
8833                                                             }
8834                                                         }
8835                                                     }
8836                                                 }
8837                                             }
8838                                             &Opcode::UwidenHigh => {
8839                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8840                                                 if let Some((pattern15_0, pattern15_1)) =
8841                                                     C::multi_lane(ctx, pattern14_0)
8842                                                 {
8843                                                     if pattern15_0 == 16 {
8844                                                         if pattern15_1 == 8 {
8845                                                             if let Some(pattern18_0) =
8846                                                                 C::def_inst(ctx, pattern9_1)
8847                                                             {
8848                                                                 let pattern19_0 =
8849                                                                     C::inst_data(ctx, pattern18_0);
8850                                                                 if let &InstructionData::Unary {
8851                                                                     opcode: ref pattern20_0,
8852                                                                     arg: pattern20_1,
8853                                                                 } = &pattern19_0
8854                                                                 {
8855                                                                     if let &Opcode::UwidenHigh =
8856                                                                         pattern20_0
8857                                                                     {
8858                                                                         let pattern22_0 =
8859                                                                             C::value_type(
8860                                                                                 ctx,
8861                                                                                 pattern20_1,
8862                                                                             );
8863                                                                         if let Some((
8864                                                                             pattern23_0,
8865                                                                             pattern23_1,
8866                                                                         )) = C::multi_lane(
8867                                                                             ctx,
8868                                                                             pattern22_0,
8869                                                                         ) {
8870                                                                             if pattern23_0 == 16 {
8871                                                                                 if pattern23_1 == 8
8872                                                                                 {
8873                                                                                     // Rule at src/isa/x64/lower.isle line 1130.
8874                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8875                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8876                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8877                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8878                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8879                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
8880                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8881                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
8882                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8883                                                                                     return Some(
8884                                                                                         expr8_0,
8885                                                                                     );
8886                                                                                 }
8887                                                                             }
8888                                                                         }
8889                                                                     }
8890                                                                 }
8891                                                             }
8892                                                         }
8893                                                     }
8894                                                 }
8895                                             }
8896                                             _ => {}
8897                                         }
8898                                     }
8899                                 }
8900                                 // Rule at src/isa/x64/lower.isle line 987.
8901                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8902                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8903                                 let expr2_0 = constructor_x64_pmulld(ctx, expr0_0, &expr1_0)?;
8904                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8905                                 return Some(expr3_0);
8906                             }
8907                             _ => {}
8908                         }
8909                     }
8910                 }
8911             }
8912             if pattern3_0 == 64 {
8913                 if pattern3_1 == 2 {
8914                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8915                     if let &InstructionData::Binary {
8916                         opcode: ref pattern7_0,
8917                         args: ref pattern7_1,
8918                     } = &pattern6_0
8919                     {
8920                         match pattern7_0 {
8921                             &Opcode::Iadd => {
8922                                 let (pattern9_0, pattern9_1) =
8923                                     C::unpack_value_array_2(ctx, pattern7_1);
8924                                 // Rule at src/isa/x64/lower.isle line 106.
8925                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8926                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8927                                 let expr2_0 = constructor_x64_paddq(ctx, expr0_0, &expr1_0)?;
8928                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8929                                 return Some(expr3_0);
8930                             }
8931                             &Opcode::Isub => {
8932                                 let (pattern9_0, pattern9_1) =
8933                                     C::unpack_value_array_2(ctx, pattern7_1);
8934                                 // Rule at src/isa/x64/lower.isle line 252.
8935                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8936                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8937                                 let expr2_0 = constructor_x64_psubq(ctx, expr0_0, &expr1_0)?;
8938                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8939                                 return Some(expr3_0);
8940                             }
8941                             &Opcode::Imul => {
8942                                 let (pattern9_0, pattern9_1) =
8943                                     C::unpack_value_array_2(ctx, pattern7_1);
8944                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
8945                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
8946                                     if let &InstructionData::Unary {
8947                                         opcode: ref pattern12_0,
8948                                         arg: pattern12_1,
8949                                     } = &pattern11_0
8950                                     {
8951                                         match pattern12_0 {
8952                                             &Opcode::SwidenLow => {
8953                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8954                                                 if let Some((pattern15_0, pattern15_1)) =
8955                                                     C::multi_lane(ctx, pattern14_0)
8956                                                 {
8957                                                     if pattern15_0 == 32 {
8958                                                         if pattern15_1 == 4 {
8959                                                             if let Some(pattern18_0) =
8960                                                                 C::def_inst(ctx, pattern9_1)
8961                                                             {
8962                                                                 let pattern19_0 =
8963                                                                     C::inst_data(ctx, pattern18_0);
8964                                                                 if let &InstructionData::Unary {
8965                                                                     opcode: ref pattern20_0,
8966                                                                     arg: pattern20_1,
8967                                                                 } = &pattern19_0
8968                                                                 {
8969                                                                     if let &Opcode::SwidenLow =
8970                                                                         pattern20_0
8971                                                                     {
8972                                                                         let pattern22_0 =
8973                                                                             C::value_type(
8974                                                                                 ctx,
8975                                                                                 pattern20_1,
8976                                                                             );
8977                                                                         if let Some((
8978                                                                             pattern23_0,
8979                                                                             pattern23_1,
8980                                                                         )) = C::multi_lane(
8981                                                                             ctx,
8982                                                                             pattern22_0,
8983                                                                         ) {
8984                                                                             if pattern23_0 == 32 {
8985                                                                                 if pattern23_1 == 4
8986                                                                                 {
8987                                                                                     // Rule at src/isa/x64/lower.isle line 1102.
8988                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8989                                                                                     let expr1_0: u8 = 80;
8990                                                                                     let expr2_0 = OperandSize::Size32;
8991                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
8992                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8993                                                                                     let expr5_0: u8 = 80;
8994                                                                                     let expr6_0 = OperandSize::Size32;
8995                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
8996                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8997                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
8998                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
8999                                                                                     return Some(
9000                                                                                         expr10_0,
9001                                                                                     );
9002                                                                                 }
9003                                                                             }
9004                                                                         }
9005                                                                     }
9006                                                                 }
9007                                                             }
9008                                                         }
9009                                                     }
9010                                                 }
9011                                             }
9012                                             &Opcode::SwidenHigh => {
9013                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9014                                                 if let Some((pattern15_0, pattern15_1)) =
9015                                                     C::multi_lane(ctx, pattern14_0)
9016                                                 {
9017                                                     if pattern15_0 == 32 {
9018                                                         if pattern15_1 == 4 {
9019                                                             if let Some(pattern18_0) =
9020                                                                 C::def_inst(ctx, pattern9_1)
9021                                                             {
9022                                                                 let pattern19_0 =
9023                                                                     C::inst_data(ctx, pattern18_0);
9024                                                                 if let &InstructionData::Unary {
9025                                                                     opcode: ref pattern20_0,
9026                                                                     arg: pattern20_1,
9027                                                                 } = &pattern19_0
9028                                                                 {
9029                                                                     if let &Opcode::SwidenHigh =
9030                                                                         pattern20_0
9031                                                                     {
9032                                                                         let pattern22_0 =
9033                                                                             C::value_type(
9034                                                                                 ctx,
9035                                                                                 pattern20_1,
9036                                                                             );
9037                                                                         if let Some((
9038                                                                             pattern23_0,
9039                                                                             pattern23_1,
9040                                                                         )) = C::multi_lane(
9041                                                                             ctx,
9042                                                                             pattern22_0,
9043                                                                         ) {
9044                                                                             if pattern23_0 == 32 {
9045                                                                                 if pattern23_1 == 4
9046                                                                                 {
9047                                                                                     // Rule at src/isa/x64/lower.isle line 1066.
9048                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9049                                                                                     let expr1_0: u8 = 250;
9050                                                                                     let expr2_0 = OperandSize::Size32;
9051                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9052                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9053                                                                                     let expr5_0: u8 = 250;
9054                                                                                     let expr6_0 = OperandSize::Size32;
9055                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9056                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9057                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
9058                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9059                                                                                     return Some(
9060                                                                                         expr10_0,
9061                                                                                     );
9062                                                                                 }
9063                                                                             }
9064                                                                         }
9065                                                                     }
9066                                                                 }
9067                                                             }
9068                                                         }
9069                                                     }
9070                                                 }
9071                                             }
9072                                             &Opcode::UwidenLow => {
9073                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9074                                                 if let Some((pattern15_0, pattern15_1)) =
9075                                                     C::multi_lane(ctx, pattern14_0)
9076                                                 {
9077                                                     if pattern15_0 == 32 {
9078                                                         if pattern15_1 == 4 {
9079                                                             if let Some(pattern18_0) =
9080                                                                 C::def_inst(ctx, pattern9_1)
9081                                                             {
9082                                                                 let pattern19_0 =
9083                                                                     C::inst_data(ctx, pattern18_0);
9084                                                                 if let &InstructionData::Unary {
9085                                                                     opcode: ref pattern20_0,
9086                                                                     arg: pattern20_1,
9087                                                                 } = &pattern19_0
9088                                                                 {
9089                                                                     if let &Opcode::UwidenLow =
9090                                                                         pattern20_0
9091                                                                     {
9092                                                                         let pattern22_0 =
9093                                                                             C::value_type(
9094                                                                                 ctx,
9095                                                                                 pattern20_1,
9096                                                                             );
9097                                                                         if let Some((
9098                                                                             pattern23_0,
9099                                                                             pattern23_1,
9100                                                                         )) = C::multi_lane(
9101                                                                             ctx,
9102                                                                             pattern22_0,
9103                                                                         ) {
9104                                                                             if pattern23_0 == 32 {
9105                                                                                 if pattern23_1 == 4
9106                                                                                 {
9107                                                                                     // Rule at src/isa/x64/lower.isle line 1178.
9108                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9109                                                                                     let expr1_0: u8 = 80;
9110                                                                                     let expr2_0 = OperandSize::Size32;
9111                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9112                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9113                                                                                     let expr5_0: u8 = 80;
9114                                                                                     let expr6_0 = OperandSize::Size32;
9115                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9116                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9117                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
9118                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9119                                                                                     return Some(
9120                                                                                         expr10_0,
9121                                                                                     );
9122                                                                                 }
9123                                                                             }
9124                                                                         }
9125                                                                     }
9126                                                                 }
9127                                                             }
9128                                                         }
9129                                                     }
9130                                                 }
9131                                             }
9132                                             &Opcode::UwidenHigh => {
9133                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9134                                                 if let Some((pattern15_0, pattern15_1)) =
9135                                                     C::multi_lane(ctx, pattern14_0)
9136                                                 {
9137                                                     if pattern15_0 == 32 {
9138                                                         if pattern15_1 == 4 {
9139                                                             if let Some(pattern18_0) =
9140                                                                 C::def_inst(ctx, pattern9_1)
9141                                                             {
9142                                                                 let pattern19_0 =
9143                                                                     C::inst_data(ctx, pattern18_0);
9144                                                                 if let &InstructionData::Unary {
9145                                                                     opcode: ref pattern20_0,
9146                                                                     arg: pattern20_1,
9147                                                                 } = &pattern19_0
9148                                                                 {
9149                                                                     if let &Opcode::UwidenHigh =
9150                                                                         pattern20_0
9151                                                                     {
9152                                                                         let pattern22_0 =
9153                                                                             C::value_type(
9154                                                                                 ctx,
9155                                                                                 pattern20_1,
9156                                                                             );
9157                                                                         if let Some((
9158                                                                             pattern23_0,
9159                                                                             pattern23_1,
9160                                                                         )) = C::multi_lane(
9161                                                                             ctx,
9162                                                                             pattern22_0,
9163                                                                         ) {
9164                                                                             if pattern23_0 == 32 {
9165                                                                                 if pattern23_1 == 4
9166                                                                                 {
9167                                                                                     // Rule at src/isa/x64/lower.isle line 1142.
9168                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9169                                                                                     let expr1_0: u8 = 250;
9170                                                                                     let expr2_0 = OperandSize::Size32;
9171                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9172                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9173                                                                                     let expr5_0: u8 = 250;
9174                                                                                     let expr6_0 = OperandSize::Size32;
9175                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9176                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9177                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
9178                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9179                                                                                     return Some(
9180                                                                                         expr10_0,
9181                                                                                     );
9182                                                                                 }
9183                                                                             }
9184                                                                         }
9185                                                                     }
9186                                                                 }
9187                                                             }
9188                                                         }
9189                                                     }
9190                                                 }
9191                                             }
9192                                             _ => {}
9193                                         }
9194                                     }
9195                                 }
9196                                 // Rule at src/isa/x64/lower.isle line 1018.
9197                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9198                                 let expr1_0 = constructor_put_in_xmm(ctx, pattern9_1)?;
9199                                 let expr2_0: u32 = 32;
9200                                 let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
9201                                 let expr4_0 = constructor_mov_rmi_to_xmm(ctx, &expr3_0)?;
9202                                 let expr5_0 = constructor_x64_psrlq(ctx, expr0_0, &expr4_0)?;
9203                                 let expr6_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9204                                 let expr7_0 = constructor_x64_pmuludq(ctx, expr5_0, &expr6_0)?;
9205                                 let expr8_0: u32 = 32;
9206                                 let expr9_0 = RegMemImm::Imm { simm32: expr8_0 };
9207                                 let expr10_0 = constructor_mov_rmi_to_xmm(ctx, &expr9_0)?;
9208                                 let expr11_0 = constructor_x64_psrlq(ctx, expr1_0, &expr10_0)?;
9209                                 let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
9210                                 let expr13_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr12_0)?;
9211                                 let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
9212                                 let expr15_0 = constructor_x64_paddq(ctx, expr7_0, &expr14_0)?;
9213                                 let expr16_0: u32 = 32;
9214                                 let expr17_0 = RegMemImm::Imm { simm32: expr16_0 };
9215                                 let expr18_0 = constructor_mov_rmi_to_xmm(ctx, &expr17_0)?;
9216                                 let expr19_0 = constructor_x64_psllq(ctx, expr15_0, &expr18_0)?;
9217                                 let expr20_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9218                                 let expr21_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr20_0)?;
9219                                 let expr22_0 = C::xmm_to_xmm_mem(ctx, expr19_0);
9220                                 let expr23_0 = constructor_x64_paddq(ctx, expr21_0, &expr22_0)?;
9221                                 let expr24_0 = constructor_output_xmm(ctx, expr23_0)?;
9222                                 return Some(expr24_0);
9223                             }
9224                             _ => {}
9225                         }
9226                     }
9227                 }
9228             }
9229             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9230             match &pattern4_0 {
9231                 &InstructionData::Binary {
9232                     opcode: ref pattern5_0,
9233                     args: ref pattern5_1,
9234                 } => {
9235                     match pattern5_0 {
9236                         &Opcode::Band => {
9237                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9238                             // Rule at src/isa/x64/lower.isle line 328.
9239                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9240                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9241                             let expr2_0 = constructor_sse_and(ctx, pattern2_0, expr0_0, &expr1_0)?;
9242                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9243                             return Some(expr3_0);
9244                         }
9245                         &Opcode::Bor => {
9246                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9247                             // Rule at src/isa/x64/lower.isle line 392.
9248                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9249                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9250                             let expr2_0 = constructor_sse_or(ctx, pattern2_0, expr0_0, &expr1_0)?;
9251                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9252                             return Some(expr3_0);
9253                         }
9254                         &Opcode::Bxor => {
9255                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9256                             // Rule at src/isa/x64/lower.isle line 453.
9257                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9258                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9259                             let expr2_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr1_0)?;
9260                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9261                             return Some(expr3_0);
9262                         }
9263                         _ => {}
9264                     }
9265                 }
9266                 &InstructionData::Ternary {
9267                     opcode: ref pattern5_0,
9268                     args: ref pattern5_1,
9269                 } => {
9270                     match pattern5_0 {
9271                         &Opcode::Bitselect => {
9272                             let (pattern7_0, pattern7_1, pattern7_2) =
9273                                 C::unpack_value_array_3(ctx, pattern5_1);
9274                             // Rule at src/isa/x64/lower.isle line 1279.
9275                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9276                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
9277                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
9278                             let expr3_0 = constructor_sse_and(ctx, pattern2_0, expr1_0, &expr2_0)?;
9279                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern7_2)?;
9280                             let expr5_0 =
9281                                 constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr4_0)?;
9282                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
9283                             let expr7_0 = constructor_sse_or(ctx, pattern2_0, expr5_0, &expr6_0)?;
9284                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9285                             return Some(expr8_0);
9286                         }
9287                         &Opcode::Vselect => {
9288                             let (pattern7_0, pattern7_1, pattern7_2) =
9289                                 C::unpack_value_array_3(ctx, pattern5_1);
9290                             // Rule at src/isa/x64/lower.isle line 1293.
9291                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_0)?;
9292                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9293                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_2)?;
9294                             let expr3_0 = constructor_x64_blend(
9295                                 ctx, pattern2_0, &expr0_0, &expr1_0, expr2_0,
9296                             )?;
9297                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
9298                             return Some(expr4_0);
9299                         }
9300                         _ => {}
9301                     }
9302                 }
9303                 &InstructionData::Unary {
9304                     opcode: ref pattern5_0,
9305                     arg: pattern5_1,
9306                 } => {
9307                     if let &Opcode::Bnot = pattern5_0 {
9308                         // Rule at src/isa/x64/lower.isle line 1274.
9309                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
9310                         let expr1_0 = constructor_vector_all_ones(ctx, pattern2_0)?;
9311                         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9312                         let expr3_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr2_0)?;
9313                         let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
9314                         return Some(expr4_0);
9315                     }
9316                 }
9317                 _ => {}
9318             }
9319         }
9320         if let Some(pattern3_0) = C::fits_in_32(ctx, pattern2_0) {
9321             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9322             if let &InstructionData::Unary {
9323                 opcode: ref pattern5_0,
9324                 arg: pattern5_1,
9325             } = &pattern4_0
9326             {
9327                 if let &Opcode::Uextend = pattern5_0 {
9328                     let pattern7_0 = C::value_type(ctx, pattern5_1);
9329                     if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
9330                         // Rule at src/isa/x64/lower.isle line 2124.
9331                         let expr0_0: Type = I32;
9332                         let expr1_0 = ExtendKind::Zero;
9333                         let expr2_0 =
9334                             constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
9335                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9336                         return Some(expr3_0);
9337                     }
9338                 }
9339             }
9340             if let Some(pattern4_0) = C::is_gpr_type(ctx, pattern2_0) {
9341                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
9342                 if let &InstructionData::Load {
9343                     opcode: ref pattern6_0,
9344                     arg: pattern6_1,
9345                     flags: pattern6_2,
9346                     offset: pattern6_3,
9347                 } = &pattern5_0
9348                 {
9349                     if let &Opcode::Load = pattern6_0 {
9350                         // Rule at src/isa/x64/lower.isle line 2514.
9351                         let expr0_0 = C::ty_bits_u16(ctx, pattern3_0);
9352                         let expr1_0: u16 = 64;
9353                         let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
9354                         let expr3_0 =
9355                             constructor_to_amode(ctx, pattern6_2, pattern6_1, pattern6_3)?;
9356                         let expr4_0 = constructor_amode_to_gpr_mem(ctx, &expr3_0)?;
9357                         let expr5_0 = constructor_x64_movzx(ctx, &expr2_0, &expr4_0)?;
9358                         let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
9359                         return Some(expr6_0);
9360                     }
9361                 }
9362             }
9363         }
9364         if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) {
9365             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9366             match &pattern4_0 {
9367                 &InstructionData::UnaryImm {
9368                     opcode: ref pattern5_0,
9369                     imm: pattern5_1,
9370                 } => {
9371                     if let &Opcode::Iconst = pattern5_0 {
9372                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
9373                         // Rule at src/isa/x64/lower.isle line 10.
9374                         let expr0_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
9375                         let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
9376                         return Some(expr1_0);
9377                     }
9378                 }
9379                 &InstructionData::UnaryBool {
9380                     opcode: ref pattern5_0,
9381                     imm: pattern5_1,
9382                 } => {
9383                     if let &Opcode::Bconst = pattern5_0 {
9384                         if pattern5_1 == true {
9385                             // Rule at src/isa/x64/lower.isle line 28.
9386                             let expr0_0: u64 = 1;
9387                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
9388                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
9389                             return Some(expr2_0);
9390                         }
9391                         if pattern5_1 == false {
9392                             // Rule at src/isa/x64/lower.isle line 24.
9393                             let expr0_0: u64 = 0;
9394                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
9395                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
9396                             return Some(expr2_0);
9397                         }
9398                     }
9399                 }
9400                 &InstructionData::Binary {
9401                     opcode: ref pattern5_0,
9402                     args: ref pattern5_1,
9403                 } => {
9404                     match pattern5_0 {
9405                         &Opcode::Imin => {
9406                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9407                             // Rule at src/isa/x64/lower.isle line 1380.
9408                             let expr0_0 = CC::L;
9409                             let expr1_0 = constructor_cmp_and_choose(
9410                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9411                             )?;
9412                             let expr2_0 = C::output(ctx, expr1_0);
9413                             return Some(expr2_0);
9414                         }
9415                         &Opcode::Umin => {
9416                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9417                             // Rule at src/isa/x64/lower.isle line 1374.
9418                             let expr0_0 = CC::B;
9419                             let expr1_0 = constructor_cmp_and_choose(
9420                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9421                             )?;
9422                             let expr2_0 = C::output(ctx, expr1_0);
9423                             return Some(expr2_0);
9424                         }
9425                         &Opcode::Imax => {
9426                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9427                             // Rule at src/isa/x64/lower.isle line 1383.
9428                             let expr0_0 = CC::NL;
9429                             let expr1_0 = constructor_cmp_and_choose(
9430                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9431                             )?;
9432                             let expr2_0 = C::output(ctx, expr1_0);
9433                             return Some(expr2_0);
9434                         }
9435                         &Opcode::Umax => {
9436                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9437                             // Rule at src/isa/x64/lower.isle line 1377.
9438                             let expr0_0 = CC::NB;
9439                             let expr1_0 = constructor_cmp_and_choose(
9440                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9441                             )?;
9442                             let expr2_0 = C::output(ctx, expr1_0);
9443                             return Some(expr2_0);
9444                         }
9445                         &Opcode::Iadd => {
9446                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9447                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9448                                 // Rule at src/isa/x64/lower.isle line 74.
9449                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9450                                 let expr1_0 =
9451                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9452                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9453                                 return Some(expr2_0);
9454                             }
9455                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9456                                 // Rule at src/isa/x64/lower.isle line 86.
9457                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9458                                 let expr1_0 =
9459                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9460                                 let expr2_0 =
9461                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9462                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9463                                 return Some(expr3_0);
9464                             }
9465                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9466                                 // Rule at src/isa/x64/lower.isle line 70.
9467                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9468                                 let expr1_0 =
9469                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9470                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9471                                 return Some(expr2_0);
9472                             }
9473                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9474                                 // Rule at src/isa/x64/lower.isle line 80.
9475                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9476                                 let expr1_0 =
9477                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9478                                 let expr2_0 =
9479                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9480                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9481                                 return Some(expr3_0);
9482                             }
9483                             // Rule at src/isa/x64/lower.isle line 64.
9484                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9485                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9486                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9487                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9488                             return Some(expr3_0);
9489                         }
9490                         &Opcode::Isub => {
9491                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9492                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9493                                 // Rule at src/isa/x64/lower.isle line 228.
9494                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9495                                 let expr1_0 =
9496                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9497                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9498                                 return Some(expr2_0);
9499                             }
9500                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9501                                 // Rule at src/isa/x64/lower.isle line 233.
9502                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9503                                 let expr1_0 =
9504                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9505                                 let expr2_0 =
9506                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
9507                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9508                                 return Some(expr3_0);
9509                             }
9510                             // Rule at src/isa/x64/lower.isle line 223.
9511                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9512                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9513                             let expr2_0 = constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
9514                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9515                             return Some(expr3_0);
9516                         }
9517                         &Opcode::Imul => {
9518                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9519                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9520                                 // Rule at src/isa/x64/lower.isle line 925.
9521                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9522                                 let expr1_0 =
9523                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9524                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9525                                 return Some(expr2_0);
9526                             }
9527                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9528                                 // Rule at src/isa/x64/lower.isle line 937.
9529                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9530                                 let expr1_0 =
9531                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9532                                 let expr2_0 =
9533                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
9534                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9535                                 return Some(expr3_0);
9536                             }
9537                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9538                                 // Rule at src/isa/x64/lower.isle line 921.
9539                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9540                                 let expr1_0 =
9541                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9542                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9543                                 return Some(expr2_0);
9544                             }
9545                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9546                                 // Rule at src/isa/x64/lower.isle line 931.
9547                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9548                                 let expr1_0 =
9549                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9550                                 let expr2_0 =
9551                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
9552                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9553                                 return Some(expr3_0);
9554                             }
9555                             // Rule at src/isa/x64/lower.isle line 916.
9556                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9557                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9558                             let expr2_0 = constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
9559                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9560                             return Some(expr3_0);
9561                         }
9562                         &Opcode::IaddIfcout => {
9563                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9564                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9565                                 // Rule at src/isa/x64/lower.isle line 171.
9566                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9567                                 let expr1_0 =
9568                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9569                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
9570                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
9571                                 return Some(expr3_0);
9572                             }
9573                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9574                                 // Rule at src/isa/x64/lower.isle line 181.
9575                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9576                                 let expr1_0 =
9577                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9578                                 let expr2_0 =
9579                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9580                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
9581                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
9582                                 return Some(expr4_0);
9583                             }
9584                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9585                                 // Rule at src/isa/x64/lower.isle line 167.
9586                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9587                                 let expr1_0 =
9588                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9589                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
9590                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
9591                                 return Some(expr3_0);
9592                             }
9593                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9594                                 // Rule at src/isa/x64/lower.isle line 177.
9595                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9596                                 let expr1_0 =
9597                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9598                                 let expr2_0 =
9599                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9600                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
9601                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
9602                                 return Some(expr4_0);
9603                             }
9604                             // Rule at src/isa/x64/lower.isle line 161.
9605                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9606                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9607                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9608                             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
9609                             let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
9610                             return Some(expr4_0);
9611                         }
9612                         &Opcode::Band => {
9613                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9614                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9615                                 // Rule at src/isa/x64/lower.isle line 317.
9616                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9617                                 let expr1_0 =
9618                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9619                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9620                                 return Some(expr2_0);
9621                             }
9622                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9623                                 // Rule at src/isa/x64/lower.isle line 305.
9624                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9625                                 let expr1_0 =
9626                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9627                                 let expr2_0 =
9628                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
9629                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9630                                 return Some(expr3_0);
9631                             }
9632                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9633                                 // Rule at src/isa/x64/lower.isle line 313.
9634                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9635                                 let expr1_0 =
9636                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9637                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9638                                 return Some(expr2_0);
9639                             }
9640                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9641                                 // Rule at src/isa/x64/lower.isle line 300.
9642                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9643                                 let expr1_0 =
9644                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9645                                 let expr2_0 =
9646                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
9647                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9648                                 return Some(expr3_0);
9649                             }
9650                             // Rule at src/isa/x64/lower.isle line 295.
9651                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9652                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9653                             let expr2_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
9654                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9655                             return Some(expr3_0);
9656                         }
9657                         &Opcode::Bor => {
9658                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9659                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9660                                 // Rule at src/isa/x64/lower.isle line 381.
9661                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9662                                 let expr1_0 =
9663                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9664                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9665                                 return Some(expr2_0);
9666                             }
9667                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9668                                 // Rule at src/isa/x64/lower.isle line 370.
9669                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9670                                 let expr1_0 =
9671                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9672                                 let expr2_0 =
9673                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
9674                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9675                                 return Some(expr3_0);
9676                             }
9677                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9678                                 // Rule at src/isa/x64/lower.isle line 377.
9679                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9680                                 let expr1_0 =
9681                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9682                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9683                                 return Some(expr2_0);
9684                             }
9685                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9686                                 // Rule at src/isa/x64/lower.isle line 365.
9687                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9688                                 let expr1_0 =
9689                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9690                                 let expr2_0 =
9691                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
9692                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9693                                 return Some(expr3_0);
9694                             }
9695                             // Rule at src/isa/x64/lower.isle line 360.
9696                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9697                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9698                             let expr2_0 = constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
9699                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9700                             return Some(expr3_0);
9701                         }
9702                         &Opcode::Bxor => {
9703                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9704                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9705                                 // Rule at src/isa/x64/lower.isle line 447.
9706                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9707                                 let expr1_0 =
9708                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9709                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9710                                 return Some(expr2_0);
9711                             }
9712                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9713                                 // Rule at src/isa/x64/lower.isle line 436.
9714                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9715                                 let expr1_0 =
9716                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9717                                 let expr2_0 =
9718                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
9719                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9720                                 return Some(expr3_0);
9721                             }
9722                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9723                                 // Rule at src/isa/x64/lower.isle line 443.
9724                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9725                                 let expr1_0 =
9726                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9727                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9728                                 return Some(expr2_0);
9729                             }
9730                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9731                                 // Rule at src/isa/x64/lower.isle line 431.
9732                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9733                                 let expr1_0 =
9734                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9735                                 let expr2_0 =
9736                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
9737                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9738                                 return Some(expr3_0);
9739                             }
9740                             // Rule at src/isa/x64/lower.isle line 426.
9741                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9742                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9743                             let expr2_0 = constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
9744                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9745                             return Some(expr3_0);
9746                         }
9747                         &Opcode::Ishl => {
9748                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9749                             // Rule at src/isa/x64/lower.isle line 483.
9750                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9751                             let expr1_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
9752                             let expr2_0 = constructor_x64_shl(ctx, pattern3_0, expr0_0, &expr1_0)?;
9753                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9754                             return Some(expr3_0);
9755                         }
9756                         &Opcode::Ushr => {
9757                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9758                             // Rule at src/isa/x64/lower.isle line 589.
9759                             let expr0_0 = ExtendKind::Zero;
9760                             let expr1_0 =
9761                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
9762                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
9763                             let expr3_0 = constructor_x64_shr(ctx, pattern3_0, expr1_0, &expr2_0)?;
9764                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9765                             return Some(expr4_0);
9766                         }
9767                         &Opcode::Sshr => {
9768                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9769                             // Rule at src/isa/x64/lower.isle line 691.
9770                             let expr0_0 = ExtendKind::Sign;
9771                             let expr1_0 =
9772                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
9773                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
9774                             let expr3_0 = constructor_x64_sar(ctx, pattern3_0, expr1_0, &expr2_0)?;
9775                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9776                             return Some(expr4_0);
9777                         }
9778                         _ => {}
9779                     }
9780                 }
9781                 &InstructionData::Unary {
9782                     opcode: ref pattern5_0,
9783                     arg: pattern5_1,
9784                 } => {
9785                     match pattern5_0 {
9786                         &Opcode::Ineg => {
9787                             // Rule at src/isa/x64/lower.isle line 884.
9788                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9789                             let expr1_0 = constructor_x64_neg(ctx, pattern3_0, expr0_0)?;
9790                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9791                             return Some(expr2_0);
9792                         }
9793                         &Opcode::Bnot => {
9794                             // Rule at src/isa/x64/lower.isle line 1253.
9795                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9796                             let expr1_0 = constructor_x64_not(ctx, pattern3_0, expr0_0)?;
9797                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9798                             return Some(expr2_0);
9799                         }
9800                         &Opcode::Breduce => {
9801                             // Rule at src/isa/x64/lower.isle line 2229.
9802                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
9803                             let expr1_0: usize = 0;
9804                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
9805                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9806                             return Some(expr3_0);
9807                         }
9808                         &Opcode::Bint => {
9809                             // Rule at src/isa/x64/lower.isle line 2237.
9810                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9811                             let expr1_0: u32 = 1;
9812                             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
9813                             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
9814                             let expr4_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr3_0)?;
9815                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
9816                             return Some(expr5_0);
9817                         }
9818                         &Opcode::Ireduce => {
9819                             // Rule at src/isa/x64/lower.isle line 2221.
9820                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
9821                             let expr1_0: usize = 0;
9822                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
9823                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9824                             return Some(expr3_0);
9825                         }
9826                         _ => {}
9827                     }
9828                 }
9829                 &InstructionData::BinaryImm64 {
9830                     opcode: ref pattern5_0,
9831                     arg: pattern5_1,
9832                     imm: pattern5_2,
9833                 } => {
9834                     if let &Opcode::IaddImm = pattern5_0 {
9835                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
9836                         // Rule at src/isa/x64/lower.isle line 196.
9837                         let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9838                         let expr1_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
9839                         let expr2_0 = constructor_reg_to_gpr_mem_imm(ctx, expr1_0)?;
9840                         let expr3_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr2_0)?;
9841                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9842                         return Some(expr4_0);
9843                     }
9844                 }
9845                 _ => {}
9846             }
9847         }
9848         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
9849             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9850             match &pattern4_0 {
9851                 &InstructionData::Binary {
9852                     opcode: ref pattern5_0,
9853                     args: ref pattern5_1,
9854                 } => {
9855                     match pattern5_0 {
9856                         &Opcode::Rotl => {
9857                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9858                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9859                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9860                                 if let &InstructionData::UnaryImm {
9861                                     opcode: ref pattern10_0,
9862                                     imm: pattern10_1,
9863                                 } = &pattern9_0
9864                                 {
9865                                     if let &Opcode::Iconst = pattern10_0 {
9866                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9867                                         // Rule at src/isa/x64/lower.isle line 823.
9868                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9869                                         let expr1_0 = C::const_to_type_masked_imm8(
9870                                             ctx,
9871                                             pattern12_0,
9872                                             pattern3_0,
9873                                         );
9874                                         let expr2_0 = constructor_x64_rotl(
9875                                             ctx, pattern3_0, expr0_0, &expr1_0,
9876                                         )?;
9877                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9878                                         return Some(expr3_0);
9879                                     }
9880                                 }
9881                             }
9882                             // Rule at src/isa/x64/lower.isle line 817.
9883                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
9884                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9885                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
9886                             let expr3_0 = constructor_x64_rotl(ctx, pattern3_0, expr1_0, &expr2_0)?;
9887                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9888                             return Some(expr4_0);
9889                         }
9890                         &Opcode::Rotr => {
9891                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9892                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9893                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9894                                 if let &InstructionData::UnaryImm {
9895                                     opcode: ref pattern10_0,
9896                                     imm: pattern10_1,
9897                                 } = &pattern9_0
9898                                 {
9899                                     if let &Opcode::Iconst = pattern10_0 {
9900                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9901                                         // Rule at src/isa/x64/lower.isle line 863.
9902                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9903                                         let expr1_0 = C::const_to_type_masked_imm8(
9904                                             ctx,
9905                                             pattern12_0,
9906                                             pattern3_0,
9907                                         );
9908                                         let expr2_0 = constructor_x64_rotr(
9909                                             ctx, pattern3_0, expr0_0, &expr1_0,
9910                                         )?;
9911                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9912                                         return Some(expr3_0);
9913                                     }
9914                                 }
9915                             }
9916                             // Rule at src/isa/x64/lower.isle line 857.
9917                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
9918                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9919                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
9920                             let expr3_0 = constructor_x64_rotr(ctx, pattern3_0, expr1_0, &expr2_0)?;
9921                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9922                             return Some(expr4_0);
9923                         }
9924                         _ => {}
9925                     }
9926                 }
9927                 &InstructionData::Unary {
9928                     opcode: ref pattern5_0,
9929                     arg: pattern5_1,
9930                 } => {
9931                     match pattern5_0 {
9932                         &Opcode::Clz => {
9933                             // Rule at src/isa/x64/lower.isle line 1785.
9934                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9935                             let expr1_0 = constructor_do_clz(ctx, pattern3_0, pattern3_0, expr0_0)?;
9936                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9937                             return Some(expr2_0);
9938                         }
9939                         &Opcode::Ctz => {
9940                             // Rule at src/isa/x64/lower.isle line 1827.
9941                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9942                             let expr1_0 = constructor_do_ctz(ctx, pattern3_0, pattern3_0, expr0_0)?;
9943                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9944                             return Some(expr2_0);
9945                         }
9946                         &Opcode::Popcnt => {
9947                             // Rule at src/isa/x64/lower.isle line 1879.
9948                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9949                             let expr1_0 = constructor_do_popcnt(ctx, pattern3_0, expr0_0)?;
9950                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9951                             return Some(expr2_0);
9952                         }
9953                         _ => {}
9954                     }
9955                 }
9956                 _ => {}
9957             }
9958         }
9959         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
9960             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9961             match &pattern4_0 {
9962                 &InstructionData::Binary {
9963                     opcode: ref pattern5_0,
9964                     args: ref pattern5_1,
9965                 } => {
9966                     match pattern5_0 {
9967                         &Opcode::Rotl => {
9968                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9969                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9970                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9971                                 if let &InstructionData::UnaryImm {
9972                                     opcode: ref pattern10_0,
9973                                     imm: pattern10_1,
9974                                 } = &pattern9_0
9975                                 {
9976                                     if let &Opcode::Iconst = pattern10_0 {
9977                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9978                                         // Rule at src/isa/x64/lower.isle line 809.
9979                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9980                                         let expr1_0 = C::const_to_type_masked_imm8(
9981                                             ctx,
9982                                             pattern12_0,
9983                                             pattern3_0,
9984                                         );
9985                                         let expr2_0 = constructor_x64_rotl(
9986                                             ctx, pattern3_0, expr0_0, &expr1_0,
9987                                         )?;
9988                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9989                                         return Some(expr3_0);
9990                                     }
9991                                 }
9992                             }
9993                             // Rule at src/isa/x64/lower.isle line 805.
9994                             let expr0_0: Type = I32;
9995                             let expr1_0 = ExtendKind::Zero;
9996                             let expr2_0 =
9997                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
9998                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9999                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
10000                             let expr5_0 = constructor_x64_rotl(ctx, pattern3_0, expr3_0, &expr4_0)?;
10001                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
10002                             return Some(expr6_0);
10003                         }
10004                         &Opcode::Rotr => {
10005                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10006                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
10007                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
10008                                 if let &InstructionData::UnaryImm {
10009                                     opcode: ref pattern10_0,
10010                                     imm: pattern10_1,
10011                                 } = &pattern9_0
10012                                 {
10013                                     if let &Opcode::Iconst = pattern10_0 {
10014                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
10015                                         // Rule at src/isa/x64/lower.isle line 849.
10016                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10017                                         let expr1_0 = C::const_to_type_masked_imm8(
10018                                             ctx,
10019                                             pattern12_0,
10020                                             pattern3_0,
10021                                         );
10022                                         let expr2_0 = constructor_x64_rotr(
10023                                             ctx, pattern3_0, expr0_0, &expr1_0,
10024                                         )?;
10025                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10026                                         return Some(expr3_0);
10027                                     }
10028                                 }
10029                             }
10030                             // Rule at src/isa/x64/lower.isle line 845.
10031                             let expr0_0: Type = I32;
10032                             let expr1_0 = ExtendKind::Zero;
10033                             let expr2_0 =
10034                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
10035                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10036                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
10037                             let expr5_0 = constructor_x64_rotr(ctx, pattern3_0, expr3_0, &expr4_0)?;
10038                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
10039                             return Some(expr6_0);
10040                         }
10041                         _ => {}
10042                     }
10043                 }
10044                 &InstructionData::Unary {
10045                     opcode: ref pattern5_0,
10046                     arg: pattern5_1,
10047                 } => {
10048                     match pattern5_0 {
10049                         &Opcode::Clz => {
10050                             // Rule at src/isa/x64/lower.isle line 1790.
10051                             let expr0_0: Type = I32;
10052                             let expr1_0: Type = I32;
10053                             let expr2_0 = ExtendKind::Zero;
10054                             let expr3_0 =
10055                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
10056                             let expr4_0 = constructor_do_clz(ctx, expr0_0, pattern3_0, expr3_0)?;
10057                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
10058                             return Some(expr5_0);
10059                         }
10060                         &Opcode::Ctz => {
10061                             // Rule at src/isa/x64/lower.isle line 1832.
10062                             let expr0_0: Type = I32;
10063                             let expr1_0: Type = I32;
10064                             let expr2_0 = ExtendKind::Zero;
10065                             let expr3_0 =
10066                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
10067                             let expr4_0 = constructor_do_ctz(ctx, expr0_0, pattern3_0, expr3_0)?;
10068                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
10069                             return Some(expr5_0);
10070                         }
10071                         &Opcode::Popcnt => {
10072                             // Rule at src/isa/x64/lower.isle line 1884.
10073                             let expr0_0: Type = I32;
10074                             let expr1_0: Type = I32;
10075                             let expr2_0 = ExtendKind::Zero;
10076                             let expr3_0 =
10077                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
10078                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
10079                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
10080                             return Some(expr5_0);
10081                         }
10082                         _ => {}
10083                     }
10084                 }
10085                 _ => {}
10086             }
10087         }
10088         if let Some(pattern3_0) = C::ty_int_bool_ref_64(ctx, pattern2_0) {
10089             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10090             if let &InstructionData::Load {
10091                 opcode: ref pattern5_0,
10092                 arg: pattern5_1,
10093                 flags: pattern5_2,
10094                 offset: pattern5_3,
10095             } = &pattern4_0
10096             {
10097                 if let &Opcode::Load = pattern5_0 {
10098                     // Rule at src/isa/x64/lower.isle line 2518.
10099                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10100                     let expr1_0 = constructor_x64_mov(ctx, &expr0_0)?;
10101                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
10102                     return Some(expr2_0);
10103                 }
10104             }
10105         }
10106         if let Some(pattern3_0) = C::ty_vec128(ctx, pattern2_0) {
10107             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10108             if let &InstructionData::Load {
10109                 opcode: ref pattern5_0,
10110                 arg: pattern5_1,
10111                 flags: pattern5_2,
10112                 offset: pattern5_3,
10113             } = &pattern4_0
10114             {
10115                 if let &Opcode::Load = pattern5_0 {
10116                     // Rule at src/isa/x64/lower.isle line 2548.
10117                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10118                     let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
10119                     let expr2_0 = constructor_x64_movdqu(ctx, &expr1_0)?;
10120                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10121                     return Some(expr3_0);
10122                 }
10123             }
10124         }
10125         if let Some(pattern3_0) = C::is_gpr_type(ctx, pattern2_0) {
10126             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10127             if let &InstructionData::Load {
10128                 opcode: ref pattern5_0,
10129                 arg: pattern5_1,
10130                 flags: pattern5_2,
10131                 offset: pattern5_3,
10132             } = &pattern4_0
10133             {
10134                 match pattern5_0 {
10135                     &Opcode::Uload8 => {
10136                         // Rule at src/isa/x64/lower.isle line 2523.
10137                         let expr0_0 = ExtMode::BQ;
10138                         let expr1_0 =
10139                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10140                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10141                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10142                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10143                         return Some(expr4_0);
10144                     }
10145                     &Opcode::Sload8 => {
10146                         // Rule at src/isa/x64/lower.isle line 2525.
10147                         let expr0_0 = ExtMode::BQ;
10148                         let expr1_0 =
10149                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10150                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10151                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10152                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10153                         return Some(expr4_0);
10154                     }
10155                     &Opcode::Uload16 => {
10156                         // Rule at src/isa/x64/lower.isle line 2527.
10157                         let expr0_0 = ExtMode::WQ;
10158                         let expr1_0 =
10159                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10160                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10161                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10162                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10163                         return Some(expr4_0);
10164                     }
10165                     &Opcode::Sload16 => {
10166                         // Rule at src/isa/x64/lower.isle line 2529.
10167                         let expr0_0 = ExtMode::WQ;
10168                         let expr1_0 =
10169                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10170                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10171                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10172                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10173                         return Some(expr4_0);
10174                     }
10175                     &Opcode::Uload32 => {
10176                         // Rule at src/isa/x64/lower.isle line 2531.
10177                         let expr0_0 = ExtMode::LQ;
10178                         let expr1_0 =
10179                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10180                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10181                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10182                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10183                         return Some(expr4_0);
10184                     }
10185                     &Opcode::Sload32 => {
10186                         // Rule at src/isa/x64/lower.isle line 2533.
10187                         let expr0_0 = ExtMode::LQ;
10188                         let expr1_0 =
10189                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10190                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10191                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10192                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10193                         return Some(expr4_0);
10194                     }
10195                     _ => {}
10196                 }
10197             }
10198         }
10199     }
10200     return None;
10201 }
10202 
10203 // Generated as internal constructor for term output_ifcout.
10204 pub fn constructor_output_ifcout<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
10205     let pattern0_0 = arg0;
10206     // Rule at src/isa/x64/lower.isle line 157.
10207     let expr0_0 = C::value_reg(ctx, pattern0_0);
10208     let expr1_0 = C::value_regs_invalid(ctx);
10209     let expr2_0 = C::output_pair(ctx, expr0_0, expr1_0);
10210     return Some(expr2_0);
10211 }
10212 
10213 // Generated as internal constructor for term sse_and.
10214 pub fn constructor_sse_and<C: Context>(
10215     ctx: &mut C,
10216     arg0: Type,
10217     arg1: Xmm,
10218     arg2: &XmmMem,
10219 ) -> Option<Xmm> {
10220     let pattern0_0 = arg0;
10221     if pattern0_0 == F32X4 {
10222         let pattern2_0 = arg1;
10223         let pattern3_0 = arg2;
10224         // Rule at src/isa/x64/lower.isle line 324.
10225         let expr0_0 = constructor_x64_andps(ctx, pattern2_0, pattern3_0)?;
10226         return Some(expr0_0);
10227     }
10228     if pattern0_0 == F64X2 {
10229         let pattern2_0 = arg1;
10230         let pattern3_0 = arg2;
10231         // Rule at src/isa/x64/lower.isle line 325.
10232         let expr0_0 = constructor_x64_andpd(ctx, pattern2_0, pattern3_0)?;
10233         return Some(expr0_0);
10234     }
10235     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
10236         let pattern2_0 = arg1;
10237         let pattern3_0 = arg2;
10238         // Rule at src/isa/x64/lower.isle line 326.
10239         let expr0_0 = constructor_x64_pand(ctx, pattern2_0, pattern3_0)?;
10240         return Some(expr0_0);
10241     }
10242     return None;
10243 }
10244 
10245 // Generated as internal constructor for term sse_or.
10246 pub fn constructor_sse_or<C: Context>(
10247     ctx: &mut C,
10248     arg0: Type,
10249     arg1: Xmm,
10250     arg2: &XmmMem,
10251 ) -> Option<Xmm> {
10252     let pattern0_0 = arg0;
10253     if pattern0_0 == F32X4 {
10254         let pattern2_0 = arg1;
10255         let pattern3_0 = arg2;
10256         // Rule at src/isa/x64/lower.isle line 388.
10257         let expr0_0 = constructor_x64_orps(ctx, pattern2_0, pattern3_0)?;
10258         return Some(expr0_0);
10259     }
10260     if pattern0_0 == F64X2 {
10261         let pattern2_0 = arg1;
10262         let pattern3_0 = arg2;
10263         // Rule at src/isa/x64/lower.isle line 389.
10264         let expr0_0 = constructor_x64_orpd(ctx, pattern2_0, pattern3_0)?;
10265         return Some(expr0_0);
10266     }
10267     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
10268         let pattern2_0 = arg1;
10269         let pattern3_0 = arg2;
10270         // Rule at src/isa/x64/lower.isle line 390.
10271         let expr0_0 = constructor_x64_por(ctx, pattern2_0, pattern3_0)?;
10272         return Some(expr0_0);
10273     }
10274     return None;
10275 }
10276 
10277 // Generated as internal constructor for term or_i128.
10278 pub fn constructor_or_i128<C: Context>(
10279     ctx: &mut C,
10280     arg0: ValueRegs,
10281     arg1: ValueRegs,
10282 ) -> Option<ValueRegs> {
10283     let pattern0_0 = arg0;
10284     let pattern1_0 = arg1;
10285     // Rule at src/isa/x64/lower.isle line 399.
10286     let expr0_0: usize = 0;
10287     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10288     let expr2_0: usize = 1;
10289     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10290     let expr4_0: usize = 0;
10291     let expr5_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr4_0)?;
10292     let expr6_0: usize = 1;
10293     let expr7_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr6_0)?;
10294     let expr8_0: Type = I64;
10295     let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10296     let expr10_0 = constructor_x64_or(ctx, expr8_0, expr1_0, &expr9_0)?;
10297     let expr11_0: Type = I64;
10298     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
10299     let expr13_0 = constructor_x64_or(ctx, expr11_0, expr3_0, &expr12_0)?;
10300     let expr14_0 = constructor_value_gprs(ctx, expr10_0, expr13_0)?;
10301     return Some(expr14_0);
10302 }
10303 
10304 // Generated as internal constructor for term shl_i128.
10305 pub fn constructor_shl_i128<C: Context>(
10306     ctx: &mut C,
10307     arg0: ValueRegs,
10308     arg1: Gpr,
10309 ) -> Option<ValueRegs> {
10310     let pattern0_0 = arg0;
10311     let pattern1_0 = arg1;
10312     // Rule at src/isa/x64/lower.isle line 489.
10313     let expr0_0: usize = 0;
10314     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10315     let expr2_0: usize = 1;
10316     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10317     let expr4_0: Type = I64;
10318     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10319     let expr6_0 = constructor_x64_shl(ctx, expr4_0, expr1_0, &expr5_0)?;
10320     let expr7_0: Type = I64;
10321     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10322     let expr9_0 = constructor_x64_shl(ctx, expr7_0, expr3_0, &expr8_0)?;
10323     let expr10_0: Type = I64;
10324     let expr11_0: Type = I64;
10325     let expr12_0: Type = I64;
10326     let expr13_0: u64 = 64;
10327     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
10328     let expr15_0 = C::gpr_new(ctx, expr14_0);
10329     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
10330     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
10331     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
10332     let expr19_0 = constructor_x64_shr(ctx, expr10_0, expr1_0, &expr18_0)?;
10333     let expr20_0: Type = I64;
10334     let expr21_0: u64 = 0;
10335     let expr22_0 = constructor_imm(ctx, expr20_0, expr21_0)?;
10336     let expr23_0 = C::gpr_new(ctx, expr22_0);
10337     let expr24_0 = OperandSize::Size64;
10338     let expr25_0: u32 = 127;
10339     let expr26_0 = RegMemImm::Imm { simm32: expr25_0 };
10340     let expr27_0 = C::gpr_mem_imm_new(ctx, &expr26_0);
10341     let expr28_0 = constructor_x64_test(ctx, &expr24_0, &expr27_0, pattern1_0)?;
10342     let expr29_0: Type = I64;
10343     let expr30_0 = CC::Z;
10344     let expr31_0 = C::gpr_to_gpr_mem(ctx, expr23_0);
10345     let expr32_0 = constructor_cmove(ctx, expr29_0, &expr30_0, &expr31_0, expr19_0)?;
10346     let expr33_0 = constructor_with_flags_reg(ctx, &expr28_0, &expr32_0)?;
10347     let expr34_0 = C::gpr_new(ctx, expr33_0);
10348     let expr35_0: Type = I64;
10349     let expr36_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
10350     let expr37_0 = constructor_x64_or(ctx, expr35_0, expr34_0, &expr36_0)?;
10351     let expr38_0 = OperandSize::Size64;
10352     let expr39_0: u32 = 64;
10353     let expr40_0 = RegMemImm::Imm { simm32: expr39_0 };
10354     let expr41_0 = C::gpr_mem_imm_new(ctx, &expr40_0);
10355     let expr42_0 = constructor_x64_test(ctx, &expr38_0, &expr41_0, pattern1_0)?;
10356     let expr43_0: Type = I64;
10357     let expr44_0 = CC::Z;
10358     let expr45_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
10359     let expr46_0 = constructor_cmove(ctx, expr43_0, &expr44_0, &expr45_0, expr23_0)?;
10360     let expr47_0: Type = I64;
10361     let expr48_0 = CC::Z;
10362     let expr49_0 = C::gpr_to_gpr_mem(ctx, expr37_0);
10363     let expr50_0 = constructor_cmove(ctx, expr47_0, &expr48_0, &expr49_0, expr6_0)?;
10364     let expr51_0 = constructor_consumes_flags_concat(ctx, &expr46_0, &expr50_0)?;
10365     let expr52_0 = constructor_with_flags(ctx, &expr42_0, &expr51_0)?;
10366     return Some(expr52_0);
10367 }
10368 
10369 // Generated as internal constructor for term ishl_i8x16_mask.
10370 pub fn constructor_ishl_i8x16_mask<C: Context>(
10371     ctx: &mut C,
10372     arg0: &RegMemImm,
10373 ) -> Option<SyntheticAmode> {
10374     let pattern0_0 = arg0;
10375     match pattern0_0 {
10376         &RegMemImm::Imm { simm32: pattern1_0 } => {
10377             // Rule at src/isa/x64/lower.isle line 552.
10378             let expr0_0 = C::ishl_i8x16_mask_for_const(ctx, pattern1_0);
10379             return Some(expr0_0);
10380         }
10381         &RegMemImm::Reg { reg: pattern1_0 } => {
10382             // Rule at src/isa/x64/lower.isle line 561.
10383             let expr0_0 = C::ishl_i8x16_mask_table(ctx);
10384             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
10385             let expr2_0: Type = I64;
10386             let expr3_0 = C::gpr_new(ctx, pattern1_0);
10387             let expr4_0: u8 = 4;
10388             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
10389             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
10390             let expr7_0: u32 = 0;
10391             let expr8_0: u8 = 0;
10392             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
10393             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
10394             return Some(expr10_0);
10395         }
10396         &RegMemImm::Mem {
10397             addr: ref pattern1_0,
10398         } => {
10399             // Rule at src/isa/x64/lower.isle line 571.
10400             let expr0_0: Type = I64;
10401             let expr1_0 = ExtKind::None;
10402             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
10403             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
10404             let expr4_0 = constructor_ishl_i8x16_mask(ctx, &expr3_0)?;
10405             return Some(expr4_0);
10406         }
10407         _ => {}
10408     }
10409     return None;
10410 }
10411 
10412 // Generated as internal constructor for term shr_i128.
10413 pub fn constructor_shr_i128<C: Context>(
10414     ctx: &mut C,
10415     arg0: ValueRegs,
10416     arg1: Gpr,
10417 ) -> Option<ValueRegs> {
10418     let pattern0_0 = arg0;
10419     let pattern1_0 = arg1;
10420     // Rule at src/isa/x64/lower.isle line 596.
10421     let expr0_0: usize = 0;
10422     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10423     let expr2_0: usize = 1;
10424     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10425     let expr4_0: Type = I64;
10426     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10427     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
10428     let expr7_0: Type = I64;
10429     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10430     let expr9_0 = constructor_x64_shr(ctx, expr7_0, expr3_0, &expr8_0)?;
10431     let expr10_0: Type = I64;
10432     let expr11_0: Type = I64;
10433     let expr12_0: Type = I64;
10434     let expr13_0: u64 = 64;
10435     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
10436     let expr15_0 = C::gpr_new(ctx, expr14_0);
10437     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
10438     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
10439     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
10440     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
10441     let expr20_0 = OperandSize::Size64;
10442     let expr21_0: u32 = 127;
10443     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
10444     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
10445     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
10446     let expr25_0: Type = I64;
10447     let expr26_0 = CC::Z;
10448     let expr27_0: Type = I64;
10449     let expr28_0: u64 = 0;
10450     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
10451     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
10452     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
10453     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
10454     let expr33_0 = C::gpr_new(ctx, expr32_0);
10455     let expr34_0: Type = I64;
10456     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr6_0);
10457     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr33_0, &expr35_0)?;
10458     let expr37_0 = OperandSize::Size64;
10459     let expr38_0: u32 = 64;
10460     let expr39_0 = RegMemImm::Imm { simm32: expr38_0 };
10461     let expr40_0 = C::gpr_mem_imm_new(ctx, &expr39_0);
10462     let expr41_0 = constructor_x64_test(ctx, &expr37_0, &expr40_0, pattern1_0)?;
10463     let expr42_0: Type = I64;
10464     let expr43_0 = CC::Z;
10465     let expr44_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
10466     let expr45_0 = constructor_cmove(ctx, expr42_0, &expr43_0, &expr44_0, expr9_0)?;
10467     let expr46_0: Type = I64;
10468     let expr47_0 = CC::Z;
10469     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
10470     let expr49_0: Type = I64;
10471     let expr50_0: u64 = 0;
10472     let expr51_0 = constructor_imm(ctx, expr49_0, expr50_0)?;
10473     let expr52_0 = C::gpr_new(ctx, expr51_0);
10474     let expr53_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr52_0)?;
10475     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr45_0, &expr53_0)?;
10476     let expr55_0 = constructor_with_flags(ctx, &expr41_0, &expr54_0)?;
10477     return Some(expr55_0);
10478 }
10479 
10480 // Generated as internal constructor for term ushr_i8x16_mask.
10481 pub fn constructor_ushr_i8x16_mask<C: Context>(
10482     ctx: &mut C,
10483     arg0: &RegMemImm,
10484 ) -> Option<SyntheticAmode> {
10485     let pattern0_0 = arg0;
10486     match pattern0_0 {
10487         &RegMemImm::Imm { simm32: pattern1_0 } => {
10488             // Rule at src/isa/x64/lower.isle line 653.
10489             let expr0_0 = C::ushr_i8x16_mask_for_const(ctx, pattern1_0);
10490             return Some(expr0_0);
10491         }
10492         &RegMemImm::Reg { reg: pattern1_0 } => {
10493             // Rule at src/isa/x64/lower.isle line 662.
10494             let expr0_0 = C::ushr_i8x16_mask_table(ctx);
10495             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
10496             let expr2_0: Type = I64;
10497             let expr3_0 = C::gpr_new(ctx, pattern1_0);
10498             let expr4_0: u8 = 4;
10499             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
10500             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
10501             let expr7_0: u32 = 0;
10502             let expr8_0: u8 = 0;
10503             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
10504             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
10505             return Some(expr10_0);
10506         }
10507         &RegMemImm::Mem {
10508             addr: ref pattern1_0,
10509         } => {
10510             // Rule at src/isa/x64/lower.isle line 673.
10511             let expr0_0: Type = I64;
10512             let expr1_0 = ExtKind::None;
10513             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
10514             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
10515             let expr4_0 = constructor_ushr_i8x16_mask(ctx, &expr3_0)?;
10516             return Some(expr4_0);
10517         }
10518         _ => {}
10519     }
10520     return None;
10521 }
10522 
10523 // Generated as internal constructor for term sar_i128.
10524 pub fn constructor_sar_i128<C: Context>(
10525     ctx: &mut C,
10526     arg0: ValueRegs,
10527     arg1: Gpr,
10528 ) -> Option<ValueRegs> {
10529     let pattern0_0 = arg0;
10530     let pattern1_0 = arg1;
10531     // Rule at src/isa/x64/lower.isle line 698.
10532     let expr0_0: usize = 0;
10533     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10534     let expr2_0: usize = 1;
10535     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10536     let expr4_0: Type = I64;
10537     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10538     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
10539     let expr7_0: Type = I64;
10540     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10541     let expr9_0 = constructor_x64_sar(ctx, expr7_0, expr3_0, &expr8_0)?;
10542     let expr10_0: Type = I64;
10543     let expr11_0: Type = I64;
10544     let expr12_0: Type = I64;
10545     let expr13_0: u64 = 64;
10546     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
10547     let expr15_0 = C::gpr_new(ctx, expr14_0);
10548     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
10549     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
10550     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
10551     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
10552     let expr20_0 = OperandSize::Size64;
10553     let expr21_0: u32 = 127;
10554     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
10555     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
10556     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
10557     let expr25_0: Type = I64;
10558     let expr26_0 = CC::Z;
10559     let expr27_0: Type = I64;
10560     let expr28_0: u64 = 0;
10561     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
10562     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
10563     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
10564     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
10565     let expr33_0 = C::gpr_new(ctx, expr32_0);
10566     let expr34_0: Type = I64;
10567     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
10568     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr6_0, &expr35_0)?;
10569     let expr37_0: Type = I64;
10570     let expr38_0: u8 = 63;
10571     let expr39_0 = C::imm8_to_imm8_gpr(ctx, expr38_0);
10572     let expr40_0 = constructor_x64_sar(ctx, expr37_0, expr3_0, &expr39_0)?;
10573     let expr41_0 = OperandSize::Size64;
10574     let expr42_0: u32 = 64;
10575     let expr43_0 = RegMemImm::Imm { simm32: expr42_0 };
10576     let expr44_0 = C::gpr_mem_imm_new(ctx, &expr43_0);
10577     let expr45_0 = constructor_x64_test(ctx, &expr41_0, &expr44_0, pattern1_0)?;
10578     let expr46_0: Type = I64;
10579     let expr47_0 = CC::Z;
10580     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
10581     let expr49_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr9_0)?;
10582     let expr50_0: Type = I64;
10583     let expr51_0 = CC::Z;
10584     let expr52_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
10585     let expr53_0 = constructor_cmove(ctx, expr50_0, &expr51_0, &expr52_0, expr40_0)?;
10586     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr49_0, &expr53_0)?;
10587     let expr55_0 = constructor_with_flags(ctx, &expr45_0, &expr54_0)?;
10588     return Some(expr55_0);
10589 }
10590 
10591 // Generated as internal constructor for term sshr_i8x16_bigger_shift.
10592 pub fn constructor_sshr_i8x16_bigger_shift<C: Context>(
10593     ctx: &mut C,
10594     arg0: Type,
10595     arg1: &RegMemImm,
10596 ) -> Option<XmmMemImm> {
10597     let pattern0_0 = arg0;
10598     let pattern1_0 = arg1;
10599     match pattern1_0 {
10600         &RegMemImm::Imm { simm32: pattern2_0 } => {
10601             // Rule at src/isa/x64/lower.isle line 762.
10602             let expr0_0: u32 = 8;
10603             let expr1_0 = C::u32_add(ctx, pattern2_0, expr0_0);
10604             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
10605             let expr3_0 = C::xmm_mem_imm_new(ctx, &expr2_0);
10606             return Some(expr3_0);
10607         }
10608         &RegMemImm::Reg { reg: pattern2_0 } => {
10609             // Rule at src/isa/x64/lower.isle line 764.
10610             let expr0_0 = C::gpr_new(ctx, pattern2_0);
10611             let expr1_0: u32 = 8;
10612             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
10613             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
10614             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr0_0, &expr3_0)?;
10615             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
10616             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
10617             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
10618             return Some(expr7_0);
10619         }
10620         &RegMemImm::Mem {
10621             addr: ref pattern2_0,
10622         } => {
10623             // Rule at src/isa/x64/lower.isle line 768.
10624             let expr0_0: u64 = 8;
10625             let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
10626             let expr2_0 = C::gpr_new(ctx, expr1_0);
10627             let expr3_0 = C::gpr_mem_imm_new(ctx, pattern1_0);
10628             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr2_0, &expr3_0)?;
10629             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
10630             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
10631             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
10632             return Some(expr7_0);
10633         }
10634         _ => {}
10635     }
10636     return None;
10637 }
10638 
10639 // Generated as internal constructor for term sse_and_not.
10640 pub fn constructor_sse_and_not<C: Context>(
10641     ctx: &mut C,
10642     arg0: Type,
10643     arg1: Xmm,
10644     arg2: &XmmMem,
10645 ) -> Option<Xmm> {
10646     let pattern0_0 = arg0;
10647     if pattern0_0 == F32X4 {
10648         let pattern2_0 = arg1;
10649         let pattern3_0 = arg2;
10650         // Rule at src/isa/x64/lower.isle line 1194.
10651         let expr0_0 = constructor_x64_andnps(ctx, pattern2_0, pattern3_0)?;
10652         return Some(expr0_0);
10653     }
10654     if pattern0_0 == F64X2 {
10655         let pattern2_0 = arg1;
10656         let pattern3_0 = arg2;
10657         // Rule at src/isa/x64/lower.isle line 1195.
10658         let expr0_0 = constructor_x64_andnpd(ctx, pattern2_0, pattern3_0)?;
10659         return Some(expr0_0);
10660     }
10661     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
10662         let pattern2_0 = arg1;
10663         let pattern3_0 = arg2;
10664         // Rule at src/isa/x64/lower.isle line 1196.
10665         let expr0_0 = constructor_x64_pandn(ctx, pattern2_0, pattern3_0)?;
10666         return Some(expr0_0);
10667     }
10668     return None;
10669 }
10670 
10671 // Generated as internal constructor for term i128_not.
10672 pub fn constructor_i128_not<C: Context>(ctx: &mut C, arg0: Value) -> Option<ValueRegs> {
10673     let pattern0_0 = arg0;
10674     // Rule at src/isa/x64/lower.isle line 1259.
10675     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
10676     let expr1_0: usize = 0;
10677     let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
10678     let expr3_0: usize = 1;
10679     let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
10680     let expr5_0: Type = I64;
10681     let expr6_0 = constructor_x64_not(ctx, expr5_0, expr2_0)?;
10682     let expr7_0: Type = I64;
10683     let expr8_0 = constructor_x64_not(ctx, expr7_0, expr4_0)?;
10684     let expr9_0 = constructor_value_gprs(ctx, expr6_0, expr8_0)?;
10685     return Some(expr9_0);
10686 }
10687 
10688 // Generated as internal constructor for term vec_insert_lane.
10689 pub fn constructor_vec_insert_lane<C: Context>(
10690     ctx: &mut C,
10691     arg0: Type,
10692     arg1: Xmm,
10693     arg2: &RegMem,
10694     arg3: u8,
10695 ) -> Option<Xmm> {
10696     let pattern0_0 = arg0;
10697     if pattern0_0 == I8X16 {
10698         let pattern2_0 = arg1;
10699         let pattern3_0 = arg2;
10700         let pattern4_0 = arg3;
10701         // Rule at src/isa/x64/lower.isle line 1313.
10702         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10703         let expr1_0 = constructor_x64_pinsrb(ctx, pattern2_0, &expr0_0, pattern4_0)?;
10704         return Some(expr1_0);
10705     }
10706     if pattern0_0 == I16X8 {
10707         let pattern2_0 = arg1;
10708         let pattern3_0 = arg2;
10709         let pattern4_0 = arg3;
10710         // Rule at src/isa/x64/lower.isle line 1317.
10711         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10712         let expr1_0 = constructor_x64_pinsrw(ctx, pattern2_0, &expr0_0, pattern4_0)?;
10713         return Some(expr1_0);
10714     }
10715     if pattern0_0 == I32X4 {
10716         let pattern2_0 = arg1;
10717         let pattern3_0 = arg2;
10718         let pattern4_0 = arg3;
10719         // Rule at src/isa/x64/lower.isle line 1321.
10720         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10721         let expr1_0 = OperandSize::Size32;
10722         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
10723         return Some(expr2_0);
10724     }
10725     if pattern0_0 == I64X2 {
10726         let pattern2_0 = arg1;
10727         let pattern3_0 = arg2;
10728         let pattern4_0 = arg3;
10729         // Rule at src/isa/x64/lower.isle line 1325.
10730         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10731         let expr1_0 = OperandSize::Size64;
10732         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
10733         return Some(expr2_0);
10734     }
10735     if pattern0_0 == F32X4 {
10736         let pattern2_0 = arg1;
10737         let pattern3_0 = arg2;
10738         let pattern4_0 = arg3;
10739         // Rule at src/isa/x64/lower.isle line 1329.
10740         let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
10741         let expr1_0 = C::sse_insertps_lane_imm(ctx, pattern4_0);
10742         let expr2_0 = constructor_x64_insertps(ctx, pattern2_0, &expr0_0, expr1_0)?;
10743         return Some(expr2_0);
10744     }
10745     if pattern0_0 == F64X2 {
10746         let pattern2_0 = arg1;
10747         let pattern3_0 = arg2;
10748         if let &RegMem::Reg { reg: pattern4_0 } = pattern3_0 {
10749             let pattern5_0 = arg3;
10750             if pattern5_0 == 0 {
10751                 // Rule at src/isa/x64/lower.isle line 1351.
10752                 let expr0_0 = constructor_reg_to_xmm_mem(ctx, pattern4_0)?;
10753                 let expr1_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr0_0)?;
10754                 return Some(expr1_0);
10755             }
10756         }
10757         let pattern4_0 = arg3;
10758         if pattern4_0 == 0 {
10759             // Rule at src/isa/x64/lower.isle line 1353.
10760             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
10761             let expr1_0 = constructor_x64_movsd_load(ctx, &expr0_0)?;
10762             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
10763             let expr3_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr2_0)?;
10764             return Some(expr3_0);
10765         }
10766         if pattern4_0 == 1 {
10767             // Rule at src/isa/x64/lower.isle line 1361.
10768             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
10769             let expr1_0 = constructor_x64_movlhps(ctx, pattern2_0, &expr0_0)?;
10770             return Some(expr1_0);
10771         }
10772     }
10773     return None;
10774 }
10775 
10776 // Generated as internal constructor for term cmp_and_choose.
10777 pub fn constructor_cmp_and_choose<C: Context>(
10778     ctx: &mut C,
10779     arg0: Type,
10780     arg1: &CC,
10781     arg2: Value,
10782     arg3: Value,
10783 ) -> Option<ValueRegs> {
10784     let pattern0_0 = arg0;
10785     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
10786         let pattern2_0 = arg1;
10787         let pattern3_0 = arg2;
10788         let pattern4_0 = arg3;
10789         // Rule at src/isa/x64/lower.isle line 1369.
10790         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern1_0);
10791         let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern3_0)?;
10792         let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
10793         let expr3_0 = constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?;
10794         let expr4_0 = constructor_put_in_gpr_mem(ctx, pattern4_0)?;
10795         let expr5_0 = constructor_put_in_gpr(ctx, pattern3_0)?;
10796         let expr6_0 = constructor_cmove(ctx, pattern1_0, pattern2_0, &expr4_0, expr5_0)?;
10797         let expr7_0 = constructor_with_flags_reg(ctx, &expr3_0, &expr6_0)?;
10798         let expr8_0 = C::value_reg(ctx, expr7_0);
10799         return Some(expr8_0);
10800     }
10801     return None;
10802 }
10803 
10804 // Generated as internal constructor for term do_clz.
10805 pub fn constructor_do_clz<C: Context>(
10806     ctx: &mut C,
10807     arg0: Type,
10808     arg1: Type,
10809     arg2: Gpr,
10810 ) -> Option<Gpr> {
10811     let pattern0_0 = arg0;
10812     let pattern1_0 = arg1;
10813     let pattern2_0 = arg2;
10814     // Rule at src/isa/x64/lower.isle line 1810.
10815     let expr0_0: Type = I64;
10816     let expr1_0: i64 = -1;
10817     let expr2_0 = constructor_imm_i64(ctx, expr0_0, expr1_0)?;
10818     let expr3_0 = C::gpr_new(ctx, expr2_0);
10819     let expr4_0 = constructor_bsr_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
10820     let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
10821     let expr6_0 = C::ty_bits_u64(ctx, pattern1_0);
10822     let expr7_0: u64 = 1;
10823     let expr8_0 = C::u64_sub(ctx, expr6_0, expr7_0);
10824     let expr9_0 = constructor_imm(ctx, pattern0_0, expr8_0)?;
10825     let expr10_0 = C::gpr_new(ctx, expr9_0);
10826     let expr11_0 = constructor_reg_to_gpr_mem_imm(ctx, expr5_0)?;
10827     let expr12_0 = constructor_x64_sub(ctx, pattern0_0, expr10_0, &expr11_0)?;
10828     return Some(expr12_0);
10829 }
10830 
10831 // Generated as internal constructor for term do_ctz.
10832 pub fn constructor_do_ctz<C: Context>(
10833     ctx: &mut C,
10834     arg0: Type,
10835     arg1: Type,
10836     arg2: Gpr,
10837 ) -> Option<Gpr> {
10838     let pattern0_0 = arg0;
10839     let pattern1_0 = arg1;
10840     let pattern2_0 = arg2;
10841     // Rule at src/isa/x64/lower.isle line 1851.
10842     let expr0_0: Type = I64;
10843     let expr1_0 = C::ty_bits_u64(ctx, pattern1_0);
10844     let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
10845     let expr3_0 = C::gpr_new(ctx, expr2_0);
10846     let expr4_0 = constructor_bsf_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
10847     return Some(expr4_0);
10848 }
10849 
10850 // Generated as internal constructor for term do_popcnt.
10851 pub fn constructor_do_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10852     let pattern0_0 = arg0;
10853     if pattern0_0 == I32 {
10854         let pattern2_0 = arg1;
10855         // Rule at src/isa/x64/lower.isle line 1942.
10856         let expr0_0: Type = I32;
10857         let expr1_0: u8 = 1;
10858         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
10859         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
10860         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
10861         let expr5_0: Type = I32;
10862         let expr6_0: u64 = 2004318071;
10863         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
10864         let expr8_0 = C::gpr_new(ctx, expr7_0);
10865         let expr9_0: Type = I32;
10866         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10867         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
10868         let expr12_0: Type = I32;
10869         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
10870         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
10871         let expr15_0: Type = I32;
10872         let expr16_0: u8 = 1;
10873         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
10874         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
10875         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
10876         let expr20_0: Type = I32;
10877         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10878         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
10879         let expr23_0: Type = I32;
10880         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10881         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
10882         let expr26_0: Type = I32;
10883         let expr27_0: u8 = 1;
10884         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
10885         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
10886         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
10887         let expr31_0: Type = I32;
10888         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10889         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
10890         let expr34_0: Type = I32;
10891         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
10892         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
10893         let expr37_0: Type = I32;
10894         let expr38_0: Type = I32;
10895         let expr39_0: u8 = 4;
10896         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
10897         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
10898         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
10899         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
10900         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
10901         let expr45_0: Type = I32;
10902         let expr46_0: u32 = 252645135;
10903         let expr47_0 = RegMemImm::Imm { simm32: expr46_0 };
10904         let expr48_0 = C::gpr_mem_imm_new(ctx, &expr47_0);
10905         let expr49_0 = constructor_x64_and(ctx, expr45_0, expr44_0, &expr48_0)?;
10906         let expr50_0: Type = I32;
10907         let expr51_0: u32 = 16843009;
10908         let expr52_0 = RegMemImm::Imm { simm32: expr51_0 };
10909         let expr53_0 = C::gpr_mem_imm_new(ctx, &expr52_0);
10910         let expr54_0 = constructor_x64_mul(ctx, expr50_0, expr49_0, &expr53_0)?;
10911         let expr55_0: Type = I32;
10912         let expr56_0: u8 = 24;
10913         let expr57_0 = Imm8Reg::Imm8 { imm: expr56_0 };
10914         let expr58_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr57_0);
10915         let expr59_0 = constructor_x64_shr(ctx, expr55_0, expr54_0, &expr58_0)?;
10916         return Some(expr59_0);
10917     }
10918     if pattern0_0 == I64 {
10919         let pattern2_0 = arg1;
10920         // Rule at src/isa/x64/lower.isle line 1899.
10921         let expr0_0: Type = I64;
10922         let expr1_0: u8 = 1;
10923         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
10924         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
10925         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
10926         let expr5_0: Type = I64;
10927         let expr6_0: u64 = 8608480567731124087;
10928         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
10929         let expr8_0 = C::gpr_new(ctx, expr7_0);
10930         let expr9_0: Type = I64;
10931         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10932         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
10933         let expr12_0: Type = I64;
10934         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
10935         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
10936         let expr15_0: Type = I64;
10937         let expr16_0: u8 = 1;
10938         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
10939         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
10940         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
10941         let expr20_0: Type = I64;
10942         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10943         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
10944         let expr23_0: Type = I64;
10945         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10946         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
10947         let expr26_0: Type = I64;
10948         let expr27_0: u8 = 1;
10949         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
10950         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
10951         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
10952         let expr31_0: Type = I64;
10953         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10954         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
10955         let expr34_0: Type = I64;
10956         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
10957         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
10958         let expr37_0: Type = I64;
10959         let expr38_0: Type = I64;
10960         let expr39_0: u8 = 4;
10961         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
10962         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
10963         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
10964         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
10965         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
10966         let expr45_0: Type = I64;
10967         let expr46_0: u64 = 1085102592571150095;
10968         let expr47_0 = constructor_imm(ctx, expr45_0, expr46_0)?;
10969         let expr48_0 = C::gpr_new(ctx, expr47_0);
10970         let expr49_0: Type = I64;
10971         let expr50_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
10972         let expr51_0 = constructor_x64_and(ctx, expr49_0, expr44_0, &expr50_0)?;
10973         let expr52_0: Type = I64;
10974         let expr53_0: u64 = 72340172838076673;
10975         let expr54_0 = constructor_imm(ctx, expr52_0, expr53_0)?;
10976         let expr55_0 = C::gpr_new(ctx, expr54_0);
10977         let expr56_0: Type = I64;
10978         let expr57_0 = C::gpr_to_gpr_mem_imm(ctx, expr55_0);
10979         let expr58_0 = constructor_x64_mul(ctx, expr56_0, expr51_0, &expr57_0)?;
10980         let expr59_0: Type = I64;
10981         let expr60_0: u8 = 56;
10982         let expr61_0 = Imm8Reg::Imm8 { imm: expr60_0 };
10983         let expr62_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr61_0);
10984         let expr63_0 = constructor_x64_shr(ctx, expr59_0, expr58_0, &expr62_0)?;
10985         return Some(expr63_0);
10986     }
10987     return None;
10988 }
10989 
10990 // Generated as internal constructor for term do_bitrev8.
10991 pub fn constructor_do_bitrev8<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10992     let pattern0_0 = arg0;
10993     let pattern1_0 = arg1;
10994     // Rule at src/isa/x64/lower.isle line 2031.
10995     let expr0_0 = C::ty_mask(ctx, pattern0_0);
10996     let expr1_0: u64 = 6148914691236517205;
10997     let expr2_0 = C::u64_and(ctx, expr0_0, expr1_0);
10998     let expr3_0 = constructor_imm(ctx, pattern0_0, expr2_0)?;
10999     let expr4_0 = C::gpr_new(ctx, expr3_0);
11000     let expr5_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
11001     let expr6_0 = constructor_x64_and(ctx, pattern0_0, pattern1_0, &expr5_0)?;
11002     let expr7_0: u8 = 1;
11003     let expr8_0 = Imm8Reg::Imm8 { imm: expr7_0 };
11004     let expr9_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr8_0);
11005     let expr10_0 = constructor_x64_shr(ctx, pattern0_0, pattern1_0, &expr9_0)?;
11006     let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
11007     let expr12_0 = constructor_x64_and(ctx, pattern0_0, expr10_0, &expr11_0)?;
11008     let expr13_0: u8 = 1;
11009     let expr14_0 = Imm8Reg::Imm8 { imm: expr13_0 };
11010     let expr15_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr14_0);
11011     let expr16_0 = constructor_x64_shl(ctx, pattern0_0, expr6_0, &expr15_0)?;
11012     let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr12_0);
11013     let expr18_0 = constructor_x64_or(ctx, pattern0_0, expr16_0, &expr17_0)?;
11014     let expr19_0: u64 = 3689348814741910323;
11015     let expr20_0 = C::u64_and(ctx, expr0_0, expr19_0);
11016     let expr21_0 = constructor_imm(ctx, pattern0_0, expr20_0)?;
11017     let expr22_0 = C::gpr_new(ctx, expr21_0);
11018     let expr23_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
11019     let expr24_0 = constructor_x64_and(ctx, pattern0_0, expr18_0, &expr23_0)?;
11020     let expr25_0: u8 = 2;
11021     let expr26_0 = Imm8Reg::Imm8 { imm: expr25_0 };
11022     let expr27_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr26_0);
11023     let expr28_0 = constructor_x64_shr(ctx, pattern0_0, expr18_0, &expr27_0)?;
11024     let expr29_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
11025     let expr30_0 = constructor_x64_and(ctx, pattern0_0, expr28_0, &expr29_0)?;
11026     let expr31_0: u8 = 2;
11027     let expr32_0 = Imm8Reg::Imm8 { imm: expr31_0 };
11028     let expr33_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr32_0);
11029     let expr34_0 = constructor_x64_shl(ctx, pattern0_0, expr24_0, &expr33_0)?;
11030     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr30_0);
11031     let expr36_0 = constructor_x64_or(ctx, pattern0_0, expr34_0, &expr35_0)?;
11032     let expr37_0: u64 = 1085102592571150095;
11033     let expr38_0 = C::u64_and(ctx, expr0_0, expr37_0);
11034     let expr39_0 = constructor_imm(ctx, pattern0_0, expr38_0)?;
11035     let expr40_0 = C::gpr_new(ctx, expr39_0);
11036     let expr41_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
11037     let expr42_0 = constructor_x64_and(ctx, pattern0_0, expr36_0, &expr41_0)?;
11038     let expr43_0: u8 = 4;
11039     let expr44_0 = Imm8Reg::Imm8 { imm: expr43_0 };
11040     let expr45_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr44_0);
11041     let expr46_0 = constructor_x64_shr(ctx, pattern0_0, expr36_0, &expr45_0)?;
11042     let expr47_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
11043     let expr48_0 = constructor_x64_and(ctx, pattern0_0, expr46_0, &expr47_0)?;
11044     let expr49_0: u8 = 4;
11045     let expr50_0 = Imm8Reg::Imm8 { imm: expr49_0 };
11046     let expr51_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr50_0);
11047     let expr52_0 = constructor_x64_shl(ctx, pattern0_0, expr42_0, &expr51_0)?;
11048     let expr53_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
11049     let expr54_0 = constructor_x64_or(ctx, pattern0_0, expr52_0, &expr53_0)?;
11050     return Some(expr54_0);
11051 }
11052 
11053 // Generated as internal constructor for term do_bitrev16.
11054 pub fn constructor_do_bitrev16<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11055     let pattern0_0 = arg0;
11056     let pattern1_0 = arg1;
11057     // Rule at src/isa/x64/lower.isle line 2054.
11058     let expr0_0 = constructor_do_bitrev8(ctx, pattern0_0, pattern1_0)?;
11059     let expr1_0 = C::ty_mask(ctx, pattern0_0);
11060     let expr2_0: u64 = 71777214294589695;
11061     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0);
11062     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
11063     let expr5_0 = C::gpr_new(ctx, expr4_0);
11064     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11065     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
11066     let expr8_0: u8 = 8;
11067     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
11068     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
11069     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
11070     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11071     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
11072     let expr14_0: u8 = 8;
11073     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
11074     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
11075     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
11076     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
11077     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
11078     return Some(expr19_0);
11079 }
11080 
11081 // Generated as internal constructor for term do_bitrev32.
11082 pub fn constructor_do_bitrev32<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11083     let pattern0_0 = arg0;
11084     let pattern1_0 = arg1;
11085     // Rule at src/isa/x64/lower.isle line 2066.
11086     let expr0_0 = constructor_do_bitrev16(ctx, pattern0_0, pattern1_0)?;
11087     let expr1_0 = C::ty_mask(ctx, pattern0_0);
11088     let expr2_0: u64 = 281470681808895;
11089     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0);
11090     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
11091     let expr5_0 = C::gpr_new(ctx, expr4_0);
11092     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11093     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
11094     let expr8_0: u8 = 16;
11095     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
11096     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
11097     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
11098     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11099     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
11100     let expr14_0: u8 = 16;
11101     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
11102     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
11103     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
11104     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
11105     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
11106     return Some(expr19_0);
11107 }
11108 
11109 // Generated as internal constructor for term do_bitrev64.
11110 pub fn constructor_do_bitrev64<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11111     let pattern0_0 = arg0;
11112     if pattern0_0 == I64 {
11113         let pattern2_0 = arg1;
11114         // Rule at src/isa/x64/lower.isle line 2078.
11115         let expr0_0 = constructor_do_bitrev32(ctx, pattern0_0, pattern2_0)?;
11116         let expr1_0: u64 = 4294967295;
11117         let expr2_0 = constructor_imm(ctx, pattern0_0, expr1_0)?;
11118         let expr3_0 = C::gpr_new(ctx, expr2_0);
11119         let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr3_0);
11120         let expr5_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr4_0)?;
11121         let expr6_0: u8 = 32;
11122         let expr7_0 = Imm8Reg::Imm8 { imm: expr6_0 };
11123         let expr8_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr7_0);
11124         let expr9_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr8_0)?;
11125         let expr10_0: u8 = 32;
11126         let expr11_0 = Imm8Reg::Imm8 { imm: expr10_0 };
11127         let expr12_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr11_0);
11128         let expr13_0 = constructor_x64_shl(ctx, pattern0_0, expr5_0, &expr12_0)?;
11129         let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
11130         let expr15_0 = constructor_x64_or(ctx, pattern0_0, expr13_0, &expr14_0)?;
11131         return Some(expr15_0);
11132     }
11133     return None;
11134 }
11135 
11136 // Generated as internal constructor for term generic_sextend.
11137 pub fn constructor_generic_sextend<C: Context>(
11138     ctx: &mut C,
11139     arg0: Value,
11140     arg1: Type,
11141     arg2: Type,
11142 ) -> Option<InstOutput> {
11143     let pattern0_0 = arg0;
11144     let pattern1_0 = arg1;
11145     if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) {
11146         let pattern3_0 = arg2;
11147         if let Some(pattern4_0) = C::fits_in_32(ctx, pattern3_0) {
11148             // Rule at src/isa/x64/lower.isle line 2198.
11149             let expr0_0: Type = I32;
11150             let expr1_0 = ExtendKind::Sign;
11151             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11152             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11153             return Some(expr3_0);
11154         }
11155         if let Some(pattern4_0) = C::ty_int_bool_64(ctx, pattern3_0) {
11156             // Rule at src/isa/x64/lower.isle line 2194.
11157             let expr0_0: Type = I64;
11158             let expr1_0 = ExtendKind::Sign;
11159             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11160             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11161             return Some(expr3_0);
11162         }
11163         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
11164             // Rule at src/isa/x64/lower.isle line 2188.
11165             let expr0_0: Type = I64;
11166             let expr1_0 = ExtendKind::Sign;
11167             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11168             let expr3_0 = constructor_spread_sign_bit(ctx, expr2_0)?;
11169             let expr4_0 = C::gpr_to_reg(ctx, expr2_0);
11170             let expr5_0 = C::gpr_to_reg(ctx, expr3_0);
11171             let expr6_0 = C::value_regs(ctx, expr4_0, expr5_0);
11172             let expr7_0 = C::output(ctx, expr6_0);
11173             return Some(expr7_0);
11174         }
11175     }
11176     if let Some(pattern2_0) = C::ty_int_bool_64(ctx, pattern1_0) {
11177         let pattern3_0 = arg2;
11178         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
11179             // Rule at src/isa/x64/lower.isle line 2184.
11180             let expr0_0 = C::put_in_reg(ctx, pattern0_0);
11181             let expr1_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
11182             let expr2_0 = constructor_spread_sign_bit(ctx, expr1_0)?;
11183             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
11184             let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
11185             let expr5_0 = C::output(ctx, expr4_0);
11186             return Some(expr5_0);
11187         }
11188     }
11189     let pattern2_0 = arg2;
11190     if pattern2_0 == pattern1_0 {
11191         // Rule at src/isa/x64/lower.isle line 2174.
11192         let expr0_0 = constructor_output_value(ctx, pattern0_0)?;
11193         return Some(expr0_0);
11194     }
11195     return None;
11196 }
11197 
11198 // Generated as internal constructor for term spread_sign_bit.
11199 pub fn constructor_spread_sign_bit<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<Gpr> {
11200     let pattern0_0 = arg0;
11201     // Rule at src/isa/x64/lower.isle line 2180.
11202     let expr0_0: Type = I64;
11203     let expr1_0: u8 = 63;
11204     let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
11205     let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
11206     let expr4_0 = constructor_x64_sar(ctx, expr0_0, pattern0_0, &expr3_0)?;
11207     return Some(expr4_0);
11208 }
11209