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 ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
63     fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
64     fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice;
65     fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>;
66     fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>;
67     fn value_slice_len(&mut self, arg0: ValueSlice) -> usize;
68     fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value;
69     fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg;
70     fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
71     fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
72     fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
73     fn u64_from_ieee32(&mut self, arg0: Ieee32) -> u64;
74     fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
75     fn inst_results(&mut self, arg0: Inst) -> ValueSlice;
76     fn first_result(&mut self, arg0: Inst) -> Option<Value>;
77     fn inst_data(&mut self, arg0: Inst) -> InstructionData;
78     fn value_type(&mut self, arg0: Value) -> Type;
79     fn multi_lane(&mut self, arg0: Type) -> Option<(u8, u16)>;
80     fn def_inst(&mut self, arg0: Value) -> Option<Inst>;
81     fn offset32_to_u32(&mut self, arg0: Offset32) -> u32;
82     fn emit(&mut self, arg0: &MInst) -> Unit;
83     fn trap_code_division_by_zero(&mut self) -> TrapCode;
84     fn trap_code_integer_overflow(&mut self) -> TrapCode;
85     fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;
86     fn avoid_div_traps(&mut self, arg0: Type) -> Option<()>;
87     fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance);
88     fn symbol_value_data(
89         &mut self,
90         arg0: GlobalValue,
91     ) -> Option<(ExternalName, RelocDistance, i64)>;
92     fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>;
93     fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;
94     fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;
95     fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm;
96     fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem;
97     fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem;
98     fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode;
99     fn amode_with_flags(&mut self, arg0: &Amode, arg1: MemFlags) -> Amode;
100     fn amode_imm_reg(&mut self, arg0: u32, arg1: Gpr) -> Amode;
101     fn amode_imm_reg_reg_shift(&mut self, arg0: u32, arg1: Gpr, arg2: Gpr, arg3: u8) -> Amode;
102     fn const_shift_lt_eq_3(&mut self, arg0: Value) -> Option<u8>;
103     fn sum_extend_fits_in_32_bits(
104         &mut self,
105         arg0: Offset32,
106         arg1: Type,
107         arg2: Imm64,
108     ) -> Option<u32>;
109     fn amode_offset(&mut self, arg0: &Amode, arg1: u32) -> Amode;
110     fn put_masked_in_imm8_gpr(&mut self, arg0: Value, arg1: Type) -> Imm8Gpr;
111     fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC;
112     fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8;
113     fn imm8_reg_to_imm8_gpr(&mut self, arg0: &Imm8Reg) -> Imm8Gpr;
114     fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg;
115     fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg;
116     fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm;
117     fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm;
118     fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr;
119     fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg;
120     fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem;
121     fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm;
122     fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg;
123     fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm;
124     fn temp_writable_gpr(&mut self) -> WritableGpr;
125     fn temp_writable_xmm(&mut self) -> WritableXmm;
126     fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem;
127     fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm;
128     fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm;
129     fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem;
130     fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem;
131     fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem;
132     fn xmm_new(&mut self, arg0: Reg) -> Xmm;
133     fn gpr_new(&mut self, arg0: Reg) -> Gpr;
134     fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem;
135     fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem;
136     fn gpr_to_imm8_gpr(&mut self, arg0: Gpr) -> Imm8Gpr;
137     fn imm8_to_imm8_gpr(&mut self, arg0: u8) -> Imm8Gpr;
138     fn xmm0(&mut self) -> WritableXmm;
139     fn is_xmm_type(&mut self, arg0: Type) -> Option<Type>;
140     fn is_gpr_type(&mut self, arg0: Type) -> Option<Type>;
141     fn is_single_register_type(&mut self, arg0: Type) -> Option<Type>;
142     fn avx512vl_enabled(&mut self, arg0: Type) -> Option<()>;
143     fn avx512dq_enabled(&mut self, arg0: Type) -> Option<()>;
144     fn avx512f_enabled(&mut self, arg0: Type) -> Option<()>;
145     fn avx512bitalg_enabled(&mut self, arg0: Type) -> Option<()>;
146     fn use_lzcnt(&mut self, arg0: Type) -> Option<()>;
147     fn use_bmi1(&mut self, arg0: Type) -> Option<()>;
148     fn use_popcnt(&mut self, arg0: Type) -> Option<()>;
149     fn imm8_from_value(&mut self, arg0: Value) -> Option<Imm8Reg>;
150     fn const_to_type_masked_imm8(&mut self, arg0: u64, arg1: Type) -> Imm8Gpr;
151     fn simm32_from_value(&mut self, arg0: Value) -> Option<GprMemImm>;
152     fn simm32_from_imm64(&mut self, arg0: Imm64) -> Option<GprMemImm>;
153     fn sinkable_load(&mut self, arg0: Value) -> Option<SinkableLoad>;
154     fn sink_load(&mut self, arg0: &SinkableLoad) -> RegMemImm;
155     fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode;
156     fn nonzero_u64_fits_in_u32(&mut self, arg0: u64) -> Option<u64>;
157     fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
158     fn ishl_i8x16_mask_table(&mut self) -> SyntheticAmode;
159     fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
160     fn ushr_i8x16_mask_table(&mut self) -> SyntheticAmode;
161     fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8;
162     fn popcount_4bit_table(&mut self) -> VCodeConstant;
163     fn popcount_low_mask(&mut self) -> VCodeConstant;
164 }
165 
166 /// Internal type SideEffectNoResult: defined at src/prelude.isle line 407.
167 #[derive(Clone, Debug)]
168 pub enum SideEffectNoResult {
169     Inst { inst: MInst },
170     Inst2 { inst1: MInst, inst2: MInst },
171 }
172 
173 /// Internal type ProducesFlags: defined at src/prelude.isle line 434.
174 #[derive(Clone, Debug)]
175 pub enum ProducesFlags {
176     ProducesFlagsSideEffect { inst: MInst },
177     ProducesFlagsReturnsReg { inst: MInst, result: Reg },
178     ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg },
179 }
180 
181 /// Internal type ConsumesFlags: defined at src/prelude.isle line 445.
182 #[derive(Clone, Debug)]
183 pub enum ConsumesFlags {
184     ConsumesFlagsReturnsResultWithProducer {
185         inst: MInst,
186         result: Reg,
187     },
188     ConsumesFlagsReturnsReg {
189         inst: MInst,
190         result: Reg,
191     },
192     ConsumesFlagsTwiceReturnsValueRegs {
193         inst1: MInst,
194         inst2: MInst,
195         result: ValueRegs,
196     },
197     ConsumesFlagsFourTimesReturnsValueRegs {
198         inst1: MInst,
199         inst2: MInst,
200         inst3: MInst,
201         inst4: MInst,
202         result: ValueRegs,
203     },
204 }
205 
206 /// Internal type MInst: defined at src/isa/x64/inst.isle line 8.
207 #[derive(Clone)]
208 pub enum MInst {
209     Nop {
210         len: u8,
211     },
212     AluRmiR {
213         size: OperandSize,
214         op: AluRmiROpcode,
215         src1: Gpr,
216         src2: GprMemImm,
217         dst: WritableGpr,
218     },
219     AluRM {
220         size: OperandSize,
221         op: AluRmiROpcode,
222         src1_dst: SyntheticAmode,
223         src2: Gpr,
224     },
225     UnaryRmR {
226         size: OperandSize,
227         op: UnaryRmROpcode,
228         src: GprMem,
229         dst: WritableGpr,
230     },
231     Not {
232         size: OperandSize,
233         src: Gpr,
234         dst: WritableGpr,
235     },
236     Neg {
237         size: OperandSize,
238         src: Gpr,
239         dst: WritableGpr,
240     },
241     Div {
242         size: OperandSize,
243         signed: bool,
244         divisor: GprMem,
245         dividend_lo: Gpr,
246         dividend_hi: Gpr,
247         dst_quotient: WritableGpr,
248         dst_remainder: WritableGpr,
249     },
250     MulHi {
251         size: OperandSize,
252         signed: bool,
253         src1: Gpr,
254         src2: GprMem,
255         dst_lo: WritableGpr,
256         dst_hi: WritableGpr,
257     },
258     CheckedDivOrRemSeq {
259         kind: DivOrRemKind,
260         size: OperandSize,
261         dividend_lo: Gpr,
262         dividend_hi: Gpr,
263         divisor: WritableGpr,
264         dst_quotient: WritableGpr,
265         dst_remainder: WritableGpr,
266         tmp: OptionWritableGpr,
267     },
268     SignExtendData {
269         size: OperandSize,
270         src: Gpr,
271         dst: WritableGpr,
272     },
273     Imm {
274         dst_size: OperandSize,
275         simm64: u64,
276         dst: WritableGpr,
277     },
278     MovRR {
279         size: OperandSize,
280         src: Gpr,
281         dst: WritableGpr,
282     },
283     MovzxRmR {
284         ext_mode: ExtMode,
285         src: GprMem,
286         dst: WritableGpr,
287     },
288     Mov64MR {
289         src: SyntheticAmode,
290         dst: WritableGpr,
291     },
292     LoadEffectiveAddress {
293         addr: SyntheticAmode,
294         dst: WritableGpr,
295     },
296     MovsxRmR {
297         ext_mode: ExtMode,
298         src: GprMem,
299         dst: WritableGpr,
300     },
301     MovRM {
302         size: OperandSize,
303         src: Gpr,
304         dst: SyntheticAmode,
305     },
306     ShiftR {
307         size: OperandSize,
308         kind: ShiftKind,
309         src: Gpr,
310         num_bits: Imm8Gpr,
311         dst: WritableGpr,
312     },
313     XmmRmiReg {
314         opcode: SseOpcode,
315         src1: Xmm,
316         src2: XmmMemImm,
317         dst: WritableXmm,
318     },
319     CmpRmiR {
320         size: OperandSize,
321         opcode: CmpOpcode,
322         src: GprMemImm,
323         dst: Gpr,
324     },
325     Setcc {
326         cc: CC,
327         dst: WritableGpr,
328     },
329     Cmove {
330         size: OperandSize,
331         cc: CC,
332         consequent: GprMem,
333         alternative: Gpr,
334         dst: WritableGpr,
335     },
336     XmmCmove {
337         size: OperandSize,
338         cc: CC,
339         consequent: XmmMem,
340         alternative: Xmm,
341         dst: WritableXmm,
342     },
343     Push64 {
344         src: GprMemImm,
345     },
346     Pop64 {
347         dst: WritableGpr,
348     },
349     XmmRmR {
350         op: SseOpcode,
351         src1: Xmm,
352         src2: XmmMem,
353         dst: WritableXmm,
354     },
355     XmmRmREvex {
356         op: Avx512Opcode,
357         src1: XmmMem,
358         src2: Xmm,
359         dst: WritableXmm,
360     },
361     XmmUnaryRmR {
362         op: SseOpcode,
363         src: XmmMem,
364         dst: WritableXmm,
365     },
366     XmmUnaryRmREvex {
367         op: Avx512Opcode,
368         src: XmmMem,
369         dst: WritableXmm,
370     },
371     XmmMovRM {
372         op: SseOpcode,
373         src: Reg,
374         dst: SyntheticAmode,
375     },
376     XmmLoadConst {
377         src: VCodeConstant,
378         dst: WritableReg,
379         ty: Type,
380     },
381     XmmToGpr {
382         op: SseOpcode,
383         src: Xmm,
384         dst: WritableGpr,
385         dst_size: OperandSize,
386     },
387     GprToXmm {
388         op: SseOpcode,
389         src: GprMem,
390         dst: WritableXmm,
391         src_size: OperandSize,
392     },
393     CvtUint64ToFloatSeq {
394         dst_size: OperandSize,
395         src: WritableGpr,
396         dst: WritableXmm,
397         tmp_gpr1: WritableGpr,
398         tmp_gpr2: WritableGpr,
399     },
400     CvtFloatToSintSeq {
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     CvtFloatToUintSeq {
410         dst_size: OperandSize,
411         src_size: OperandSize,
412         is_saturating: bool,
413         src: WritableXmm,
414         dst: WritableGpr,
415         tmp_gpr: WritableGpr,
416         tmp_xmm: WritableXmm,
417     },
418     XmmMinMaxSeq {
419         size: OperandSize,
420         is_min: bool,
421         lhs: Xmm,
422         rhs: Xmm,
423         dst: WritableXmm,
424     },
425     XmmCmpRmR {
426         op: SseOpcode,
427         src: XmmMem,
428         dst: Xmm,
429     },
430     XmmRmRImm {
431         op: SseOpcode,
432         src1: Reg,
433         src2: RegMem,
434         dst: WritableReg,
435         imm: u8,
436         size: OperandSize,
437     },
438     CallKnown {
439         dest: ExternalName,
440         uses: VecReg,
441         defs: VecWritableReg,
442         opcode: Opcode,
443     },
444     CallUnknown {
445         dest: RegMem,
446         uses: VecReg,
447         defs: VecWritableReg,
448         opcode: Opcode,
449     },
450     Ret {
451         rets: VecReg,
452     },
453     EpiloguePlaceholder,
454     JmpKnown {
455         dst: MachLabel,
456     },
457     JmpIf {
458         cc: CC,
459         taken: MachLabel,
460     },
461     JmpCond {
462         cc: CC,
463         taken: MachLabel,
464         not_taken: MachLabel,
465     },
466     JmpTableSeq {
467         idx: Reg,
468         tmp1: WritableReg,
469         tmp2: WritableReg,
470         default_target: MachLabel,
471         targets: VecMachLabel,
472         targets_for_term: VecMachLabel,
473     },
474     JmpUnknown {
475         target: RegMem,
476     },
477     TrapIf {
478         cc: CC,
479         trap_code: TrapCode,
480     },
481     Hlt,
482     Ud2 {
483         trap_code: TrapCode,
484     },
485     LoadExtName {
486         dst: WritableReg,
487         name: BoxExternalName,
488         offset: i64,
489     },
490     LockCmpxchg {
491         ty: Type,
492         replacement: Reg,
493         expected: Reg,
494         mem: SyntheticAmode,
495         dst_old: WritableReg,
496     },
497     AtomicRmwSeq {
498         ty: Type,
499         op: AtomicRmwOp,
500         address: Reg,
501         operand: Reg,
502         temp: WritableReg,
503         dst_old: WritableReg,
504     },
505     Fence {
506         kind: FenceKind,
507     },
508     VirtualSPOffsetAdj {
509         offset: i64,
510     },
511     XmmUninitializedValue {
512         dst: WritableXmm,
513     },
514     ElfTlsGetAddr {
515         symbol: ExternalName,
516     },
517     MachOTlsGetAddr {
518         symbol: ExternalName,
519     },
520     Unwind {
521         inst: UnwindInst,
522     },
523     DummyUse {
524         reg: Reg,
525     },
526 }
527 
528 /// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 1213.
529 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
530 pub enum ExtendKind {
531     Sign,
532     Zero,
533 }
534 
535 // Generated as internal constructor for term output_reg.
536 pub fn constructor_output_reg<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
537     let pattern0_0 = arg0;
538     // Rule at src/prelude.isle line 86.
539     let expr0_0 = C::value_reg(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 output_value.
545 pub fn constructor_output_value<C: Context>(ctx: &mut C, arg0: Value) -> Option<InstOutput> {
546     let pattern0_0 = arg0;
547     // Rule at src/prelude.isle line 90.
548     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
549     let expr1_0 = C::output(ctx, expr0_0);
550     return Some(expr1_0);
551 }
552 
553 // Generated as internal constructor for term temp_reg.
554 pub fn constructor_temp_reg<C: Context>(ctx: &mut C, arg0: Type) -> Option<Reg> {
555     let pattern0_0 = arg0;
556     // Rule at src/prelude.isle line 110.
557     let expr0_0 = C::temp_writable_reg(ctx, pattern0_0);
558     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
559     return Some(expr1_0);
560 }
561 
562 // Generated as internal constructor for term lo_reg.
563 pub fn constructor_lo_reg<C: Context>(ctx: &mut C, arg0: Value) -> Option<Reg> {
564     let pattern0_0 = arg0;
565     // Rule at src/prelude.isle line 145.
566     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
567     let expr1_0: usize = 0;
568     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
569     return Some(expr2_0);
570 }
571 
572 // Generated as internal constructor for term side_effect.
573 pub fn constructor_side_effect<C: Context>(
574     ctx: &mut C,
575     arg0: &SideEffectNoResult,
576 ) -> Option<InstOutput> {
577     let pattern0_0 = arg0;
578     match pattern0_0 {
579         &SideEffectNoResult::Inst {
580             inst: ref pattern1_0,
581         } => {
582             // Rule at src/prelude.isle line 415.
583             let expr0_0 = C::emit(ctx, pattern1_0);
584             let expr1_0 = C::output_none(ctx);
585             return Some(expr1_0);
586         }
587         &SideEffectNoResult::Inst2 {
588             inst1: ref pattern1_0,
589             inst2: ref pattern1_1,
590         } => {
591             // Rule at src/prelude.isle line 418.
592             let expr0_0 = C::emit(ctx, pattern1_0);
593             let expr1_0 = C::emit(ctx, pattern1_1);
594             let expr2_0 = C::output_none(ctx);
595             return Some(expr2_0);
596         }
597         _ => {}
598     }
599     return None;
600 }
601 
602 // Generated as internal constructor for term side_effect_concat.
603 pub fn constructor_side_effect_concat<C: Context>(
604     ctx: &mut C,
605     arg0: &SideEffectNoResult,
606     arg1: &SideEffectNoResult,
607 ) -> Option<SideEffectNoResult> {
608     let pattern0_0 = arg0;
609     if let &SideEffectNoResult::Inst {
610         inst: ref pattern1_0,
611     } = pattern0_0
612     {
613         let pattern2_0 = arg1;
614         if let &SideEffectNoResult::Inst {
615             inst: ref pattern3_0,
616         } = pattern2_0
617         {
618             // Rule at src/prelude.isle line 424.
619             let expr0_0 = SideEffectNoResult::Inst2 {
620                 inst1: pattern1_0.clone(),
621                 inst2: pattern3_0.clone(),
622             };
623             return Some(expr0_0);
624         }
625     }
626     return None;
627 }
628 
629 // Generated as internal constructor for term produces_flags_get_reg.
630 pub fn constructor_produces_flags_get_reg<C: Context>(
631     ctx: &mut C,
632     arg0: &ProducesFlags,
633 ) -> Option<Reg> {
634     let pattern0_0 = arg0;
635     if let &ProducesFlags::ProducesFlagsReturnsReg {
636         inst: ref pattern1_0,
637         result: pattern1_1,
638     } = pattern0_0
639     {
640         // Rule at src/prelude.isle line 461.
641         return Some(pattern1_1);
642     }
643     return None;
644 }
645 
646 // Generated as internal constructor for term produces_flags_ignore.
647 pub fn constructor_produces_flags_ignore<C: Context>(
648     ctx: &mut C,
649     arg0: &ProducesFlags,
650 ) -> Option<ProducesFlags> {
651     let pattern0_0 = arg0;
652     match pattern0_0 {
653         &ProducesFlags::ProducesFlagsReturnsReg {
654             inst: ref pattern1_0,
655             result: pattern1_1,
656         } => {
657             // Rule at src/prelude.isle line 466.
658             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
659                 inst: pattern1_0.clone(),
660             };
661             return Some(expr0_0);
662         }
663         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
664             inst: ref pattern1_0,
665             result: pattern1_1,
666         } => {
667             // Rule at src/prelude.isle line 468.
668             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
669                 inst: pattern1_0.clone(),
670             };
671             return Some(expr0_0);
672         }
673         _ => {}
674     }
675     return None;
676 }
677 
678 // Generated as internal constructor for term consumes_flags_concat.
679 pub fn constructor_consumes_flags_concat<C: Context>(
680     ctx: &mut C,
681     arg0: &ConsumesFlags,
682     arg1: &ConsumesFlags,
683 ) -> Option<ConsumesFlags> {
684     let pattern0_0 = arg0;
685     if let &ConsumesFlags::ConsumesFlagsReturnsReg {
686         inst: ref pattern1_0,
687         result: pattern1_1,
688     } = pattern0_0
689     {
690         let pattern2_0 = arg1;
691         if let &ConsumesFlags::ConsumesFlagsReturnsReg {
692             inst: ref pattern3_0,
693             result: pattern3_1,
694         } = pattern2_0
695         {
696             // Rule at src/prelude.isle line 475.
697             let expr0_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
698             let expr1_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
699                 inst1: pattern1_0.clone(),
700                 inst2: pattern3_0.clone(),
701                 result: expr0_0,
702             };
703             return Some(expr1_0);
704         }
705     }
706     return None;
707 }
708 
709 // Generated as internal constructor for term with_flags.
710 pub fn constructor_with_flags<C: Context>(
711     ctx: &mut C,
712     arg0: &ProducesFlags,
713     arg1: &ConsumesFlags,
714 ) -> Option<ValueRegs> {
715     let pattern0_0 = arg0;
716     match pattern0_0 {
717         &ProducesFlags::ProducesFlagsSideEffect {
718             inst: ref pattern1_0,
719         } => {
720             let pattern2_0 = arg1;
721             match pattern2_0 {
722                 &ConsumesFlags::ConsumesFlagsReturnsReg {
723                     inst: ref pattern3_0,
724                     result: pattern3_1,
725                 } => {
726                     // Rule at src/prelude.isle line 500.
727                     let expr0_0 = C::emit(ctx, pattern1_0);
728                     let expr1_0 = C::emit(ctx, pattern3_0);
729                     let expr2_0 = C::value_reg(ctx, pattern3_1);
730                     return Some(expr2_0);
731                 }
732                 &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
733                     inst1: ref pattern3_0,
734                     inst2: ref pattern3_1,
735                     result: pattern3_2,
736                 } => {
737                     // Rule at src/prelude.isle line 506.
738                     let expr0_0 = C::emit(ctx, pattern1_0);
739                     let expr1_0 = C::emit(ctx, pattern3_0);
740                     let expr2_0 = C::emit(ctx, pattern3_1);
741                     return Some(pattern3_2);
742                 }
743                 &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
744                     inst1: ref pattern3_0,
745                     inst2: ref pattern3_1,
746                     inst3: ref pattern3_2,
747                     inst4: ref pattern3_3,
748                     result: pattern3_4,
749                 } => {
750                     // Rule at src/prelude.isle line 518.
751                     let expr0_0 = C::emit(ctx, pattern1_0);
752                     let expr1_0 = C::emit(ctx, pattern3_0);
753                     let expr2_0 = C::emit(ctx, pattern3_1);
754                     let expr3_0 = C::emit(ctx, pattern3_2);
755                     let expr4_0 = C::emit(ctx, pattern3_3);
756                     return Some(pattern3_4);
757                 }
758                 _ => {}
759             }
760         }
761         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
762             inst: ref pattern1_0,
763             result: pattern1_1,
764         } => {
765             let pattern2_0 = arg1;
766             if let &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
767                 inst: ref pattern3_0,
768                 result: pattern3_1,
769             } = pattern2_0
770             {
771                 // Rule at src/prelude.isle line 494.
772                 let expr0_0 = C::emit(ctx, pattern1_0);
773                 let expr1_0 = C::emit(ctx, pattern3_0);
774                 let expr2_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
775                 return Some(expr2_0);
776             }
777         }
778         _ => {}
779     }
780     return None;
781 }
782 
783 // Generated as internal constructor for term with_flags_reg.
784 pub fn constructor_with_flags_reg<C: Context>(
785     ctx: &mut C,
786     arg0: &ProducesFlags,
787     arg1: &ConsumesFlags,
788 ) -> Option<Reg> {
789     let pattern0_0 = arg0;
790     let pattern1_0 = arg1;
791     // Rule at src/prelude.isle line 535.
792     let expr0_0 = constructor_with_flags(ctx, pattern0_0, pattern1_0)?;
793     let expr1_0: usize = 0;
794     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
795     return Some(expr2_0);
796 }
797 
798 // Generated as internal constructor for term operand_size_bits.
799 pub fn constructor_operand_size_bits<C: Context>(ctx: &mut C, arg0: &OperandSize) -> Option<u16> {
800     let pattern0_0 = arg0;
801     match pattern0_0 {
802         &OperandSize::Size8 => {
803             // Rule at src/isa/x64/inst.isle line 517.
804             let expr0_0: u16 = 8;
805             return Some(expr0_0);
806         }
807         &OperandSize::Size16 => {
808             // Rule at src/isa/x64/inst.isle line 518.
809             let expr0_0: u16 = 16;
810             return Some(expr0_0);
811         }
812         &OperandSize::Size32 => {
813             // Rule at src/isa/x64/inst.isle line 519.
814             let expr0_0: u16 = 32;
815             return Some(expr0_0);
816         }
817         &OperandSize::Size64 => {
818             // Rule at src/isa/x64/inst.isle line 520.
819             let expr0_0: u16 = 64;
820             return Some(expr0_0);
821         }
822         _ => {}
823     }
824     return None;
825 }
826 
827 // Generated as internal constructor for term amode_imm_reg_flags.
828 pub fn constructor_amode_imm_reg_flags<C: Context>(
829     ctx: &mut C,
830     arg0: u32,
831     arg1: Gpr,
832     arg2: MemFlags,
833 ) -> Option<Amode> {
834     let pattern0_0 = arg0;
835     let pattern1_0 = arg1;
836     let pattern2_0 = arg2;
837     // Rule at src/isa/x64/inst.isle line 777.
838     let expr0_0 = C::amode_imm_reg(ctx, pattern0_0, pattern1_0);
839     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern2_0);
840     return Some(expr1_0);
841 }
842 
843 // Generated as internal constructor for term amode_imm_reg_reg_shift_flags.
844 pub fn constructor_amode_imm_reg_reg_shift_flags<C: Context>(
845     ctx: &mut C,
846     arg0: u32,
847     arg1: Gpr,
848     arg2: Gpr,
849     arg3: u8,
850     arg4: MemFlags,
851 ) -> Option<Amode> {
852     let pattern0_0 = arg0;
853     let pattern1_0 = arg1;
854     let pattern2_0 = arg2;
855     let pattern3_0 = arg3;
856     let pattern4_0 = arg4;
857     // Rule at src/isa/x64/inst.isle line 784.
858     let expr0_0 = C::amode_imm_reg_reg_shift(ctx, pattern0_0, pattern1_0, pattern2_0, pattern3_0);
859     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern4_0);
860     return Some(expr1_0);
861 }
862 
863 // Generated as internal constructor for term to_amode.
864 pub fn constructor_to_amode<C: Context>(
865     ctx: &mut C,
866     arg0: MemFlags,
867     arg1: Value,
868     arg2: Offset32,
869 ) -> Option<Amode> {
870     let pattern0_0 = arg0;
871     let pattern1_0 = arg1;
872     if let Some(pattern2_0) = C::def_inst(ctx, pattern1_0) {
873         let pattern3_0 = C::inst_data(ctx, pattern2_0);
874         if let &InstructionData::Binary {
875             opcode: ref pattern4_0,
876             args: ref pattern4_1,
877         } = &pattern3_0
878         {
879             if let &Opcode::Iadd = pattern4_0 {
880                 let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
881                 if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) {
882                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
883                     match &pattern8_0 {
884                         &InstructionData::UnaryImm {
885                             opcode: ref pattern9_0,
886                             imm: pattern9_1,
887                         } => {
888                             if let &Opcode::Iconst = pattern9_0 {
889                                 let pattern11_0 = arg2;
890                                 let closure12 = || {
891                                     let expr0_0: Type = I64;
892                                     return Some(expr0_0);
893                                 };
894                                 if let Some(pattern12_0) = closure12() {
895                                     let closure13 = || {
896                                         return Some(pattern9_1);
897                                     };
898                                     if let Some(pattern13_0) = closure13() {
899                                         if let Some(pattern14_0) = C::sum_extend_fits_in_32_bits(
900                                             ctx,
901                                             pattern11_0,
902                                             pattern12_0,
903                                             pattern13_0,
904                                         ) {
905                                             // Rule at src/isa/x64/inst.isle line 831.
906                                             let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
907                                             let expr1_0 = constructor_amode_imm_reg_flags(
908                                                 ctx,
909                                                 pattern14_0,
910                                                 expr0_0,
911                                                 pattern0_0,
912                                             )?;
913                                             return Some(expr1_0);
914                                         }
915                                     }
916                                 }
917                             }
918                         }
919                         &InstructionData::Binary {
920                             opcode: ref pattern9_0,
921                             args: ref pattern9_1,
922                         } => {
923                             if let &Opcode::Ishl = pattern9_0 {
924                                 let (pattern11_0, pattern11_1) =
925                                     C::unpack_value_array_2(ctx, pattern9_1);
926                                 if let Some(pattern12_0) = C::const_shift_lt_eq_3(ctx, pattern11_1)
927                                 {
928                                     let pattern13_0 = arg2;
929                                     // Rule at src/isa/x64/inst.isle line 823.
930                                     let expr0_0 = C::offset32_to_u32(ctx, pattern13_0);
931                                     let expr1_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
932                                     let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
933                                     let expr3_0 = constructor_amode_imm_reg_reg_shift_flags(
934                                         ctx,
935                                         expr0_0,
936                                         expr1_0,
937                                         expr2_0,
938                                         pattern12_0,
939                                         pattern0_0,
940                                     )?;
941                                     return Some(expr3_0);
942                                 }
943                             }
944                         }
945                         _ => {}
946                     }
947                     if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
948                         let pattern9_0 = C::value_type(ctx, pattern8_0);
949                         let pattern10_0 = C::inst_data(ctx, pattern7_0);
950                         if let &InstructionData::Unary {
951                             opcode: ref pattern11_0,
952                             arg: pattern11_1,
953                         } = &pattern10_0
954                         {
955                             if let &Opcode::Uextend = pattern11_0 {
956                                 if let Some(pattern13_0) = C::def_inst(ctx, pattern11_1) {
957                                     let pattern14_0 = C::inst_data(ctx, pattern13_0);
958                                     if let &InstructionData::UnaryImm {
959                                         opcode: ref pattern15_0,
960                                         imm: pattern15_1,
961                                     } = &pattern14_0
962                                     {
963                                         if let &Opcode::Iconst = pattern15_0 {
964                                             let pattern17_0 = arg2;
965                                             let closure18 = || {
966                                                 return Some(pattern9_0);
967                                             };
968                                             if let Some(pattern18_0) = closure18() {
969                                                 let closure19 = || {
970                                                     return Some(pattern15_1);
971                                                 };
972                                                 if let Some(pattern19_0) = closure19() {
973                                                     if let Some(pattern20_0) =
974                                                         C::sum_extend_fits_in_32_bits(
975                                                             ctx,
976                                                             pattern17_0,
977                                                             pattern18_0,
978                                                             pattern19_0,
979                                                         )
980                                                     {
981                                                         // Rule at src/isa/x64/inst.isle line 836.
982                                                         let expr0_0 = constructor_put_in_gpr(
983                                                             ctx, pattern6_1,
984                                                         )?;
985                                                         let expr1_0 =
986                                                             constructor_amode_imm_reg_flags(
987                                                                 ctx,
988                                                                 pattern20_0,
989                                                                 expr0_0,
990                                                                 pattern0_0,
991                                                             )?;
992                                                         return Some(expr1_0);
993                                                     }
994                                                 }
995                                             }
996                                         }
997                                     }
998                                 }
999                             }
1000                         }
1001                     }
1002                 }
1003                 if let Some(pattern7_0) = C::def_inst(ctx, pattern6_1) {
1004                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
1005                     match &pattern8_0 {
1006                         &InstructionData::UnaryImm {
1007                             opcode: ref pattern9_0,
1008                             imm: pattern9_1,
1009                         } => {
1010                             if let &Opcode::Iconst = pattern9_0 {
1011                                 let pattern11_0 = arg2;
1012                                 let closure12 = || {
1013                                     let expr0_0: Type = I64;
1014                                     return Some(expr0_0);
1015                                 };
1016                                 if let Some(pattern12_0) = closure12() {
1017                                     let closure13 = || {
1018                                         return Some(pattern9_1);
1019                                     };
1020                                     if let Some(pattern13_0) = closure13() {
1021                                         if let Some(pattern14_0) = C::sum_extend_fits_in_32_bits(
1022                                             ctx,
1023                                             pattern11_0,
1024                                             pattern12_0,
1025                                             pattern13_0,
1026                                         ) {
1027                                             // Rule at src/isa/x64/inst.isle line 833.
1028                                             let expr0_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
1029                                             let expr1_0 = constructor_amode_imm_reg_flags(
1030                                                 ctx,
1031                                                 pattern14_0,
1032                                                 expr0_0,
1033                                                 pattern0_0,
1034                                             )?;
1035                                             return Some(expr1_0);
1036                                         }
1037                                     }
1038                                 }
1039                             }
1040                         }
1041                         &InstructionData::Binary {
1042                             opcode: ref pattern9_0,
1043                             args: ref pattern9_1,
1044                         } => {
1045                             if let &Opcode::Ishl = pattern9_0 {
1046                                 let (pattern11_0, pattern11_1) =
1047                                     C::unpack_value_array_2(ctx, pattern9_1);
1048                                 if let Some(pattern12_0) = C::const_shift_lt_eq_3(ctx, pattern11_1)
1049                                 {
1050                                     let pattern13_0 = arg2;
1051                                     // Rule at src/isa/x64/inst.isle line 825.
1052                                     let expr0_0 = C::offset32_to_u32(ctx, pattern13_0);
1053                                     let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
1054                                     let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
1055                                     let expr3_0 = constructor_amode_imm_reg_reg_shift_flags(
1056                                         ctx,
1057                                         expr0_0,
1058                                         expr1_0,
1059                                         expr2_0,
1060                                         pattern12_0,
1061                                         pattern0_0,
1062                                     )?;
1063                                     return Some(expr3_0);
1064                                 }
1065                             }
1066                         }
1067                         _ => {}
1068                     }
1069                     if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
1070                         let pattern9_0 = C::value_type(ctx, pattern8_0);
1071                         let pattern10_0 = C::inst_data(ctx, pattern7_0);
1072                         if let &InstructionData::Unary {
1073                             opcode: ref pattern11_0,
1074                             arg: pattern11_1,
1075                         } = &pattern10_0
1076                         {
1077                             if let &Opcode::Uextend = pattern11_0 {
1078                                 if let Some(pattern13_0) = C::def_inst(ctx, pattern11_1) {
1079                                     let pattern14_0 = C::inst_data(ctx, pattern13_0);
1080                                     if let &InstructionData::UnaryImm {
1081                                         opcode: ref pattern15_0,
1082                                         imm: pattern15_1,
1083                                     } = &pattern14_0
1084                                     {
1085                                         if let &Opcode::Iconst = pattern15_0 {
1086                                             let pattern17_0 = arg2;
1087                                             let closure18 = || {
1088                                                 return Some(pattern9_0);
1089                                             };
1090                                             if let Some(pattern18_0) = closure18() {
1091                                                 let closure19 = || {
1092                                                     return Some(pattern15_1);
1093                                                 };
1094                                                 if let Some(pattern19_0) = closure19() {
1095                                                     if let Some(pattern20_0) =
1096                                                         C::sum_extend_fits_in_32_bits(
1097                                                             ctx,
1098                                                             pattern17_0,
1099                                                             pattern18_0,
1100                                                             pattern19_0,
1101                                                         )
1102                                                     {
1103                                                         // Rule at src/isa/x64/inst.isle line 838.
1104                                                         let expr0_0 = constructor_put_in_gpr(
1105                                                             ctx, pattern6_0,
1106                                                         )?;
1107                                                         let expr1_0 =
1108                                                             constructor_amode_imm_reg_flags(
1109                                                                 ctx,
1110                                                                 pattern20_0,
1111                                                                 expr0_0,
1112                                                                 pattern0_0,
1113                                                             )?;
1114                                                         return Some(expr1_0);
1115                                                     }
1116                                                 }
1117                                             }
1118                                         }
1119                                     }
1120                                 }
1121                             }
1122                         }
1123                     }
1124                 }
1125                 let pattern7_0 = arg2;
1126                 // Rule at src/isa/x64/inst.isle line 841.
1127                 let expr0_0 = C::offset32_to_u32(ctx, pattern7_0);
1128                 let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
1129                 let expr2_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
1130                 let expr3_0: u8 = 0;
1131                 let expr4_0 = constructor_amode_imm_reg_reg_shift_flags(
1132                     ctx, expr0_0, expr1_0, expr2_0, expr3_0, pattern0_0,
1133                 )?;
1134                 return Some(expr4_0);
1135             }
1136         }
1137     }
1138     let pattern2_0 = arg2;
1139     // Rule at src/isa/x64/inst.isle line 844.
1140     let expr0_0 = C::offset32_to_u32(ctx, pattern2_0);
1141     let expr1_0 = constructor_put_in_gpr(ctx, pattern1_0)?;
1142     let expr2_0 = constructor_amode_imm_reg_flags(ctx, expr0_0, expr1_0, pattern0_0)?;
1143     return Some(expr2_0);
1144 }
1145 
1146 // Generated as internal constructor for term reg_to_gpr_mem_imm.
1147 pub fn constructor_reg_to_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Reg) -> Option<GprMemImm> {
1148     let pattern0_0 = arg0;
1149     // Rule at src/isa/x64/inst.isle line 1043.
1150     let expr0_0 = C::gpr_new(ctx, pattern0_0);
1151     let expr1_0 = C::gpr_to_gpr_mem_imm(ctx, expr0_0);
1152     return Some(expr1_0);
1153 }
1154 
1155 // Generated as internal constructor for term put_in_gpr.
1156 pub fn constructor_put_in_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1157     let pattern0_0 = arg0;
1158     // Rule at src/isa/x64/inst.isle line 1050.
1159     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1160     let expr1_0 = C::gpr_new(ctx, expr0_0);
1161     return Some(expr1_0);
1162 }
1163 
1164 // Generated as internal constructor for term put_in_gpr_mem.
1165 pub fn constructor_put_in_gpr_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMem> {
1166     let pattern0_0 = arg0;
1167     // Rule at src/isa/x64/inst.isle line 1057.
1168     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1169     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
1170     return Some(expr1_0);
1171 }
1172 
1173 // Generated as internal constructor for term put_in_gpr_mem_imm.
1174 pub fn constructor_put_in_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMemImm> {
1175     let pattern0_0 = arg0;
1176     // Rule at src/isa/x64/inst.isle line 1064.
1177     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1178     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1179     return Some(expr1_0);
1180 }
1181 
1182 // Generated as internal constructor for term put_in_xmm.
1183 pub fn constructor_put_in_xmm<C: Context>(ctx: &mut C, arg0: Value) -> Option<Xmm> {
1184     let pattern0_0 = arg0;
1185     // Rule at src/isa/x64/inst.isle line 1071.
1186     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1187     let expr1_0 = C::xmm_new(ctx, expr0_0);
1188     return Some(expr1_0);
1189 }
1190 
1191 // Generated as internal constructor for term put_in_xmm_mem.
1192 pub fn constructor_put_in_xmm_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMem> {
1193     let pattern0_0 = arg0;
1194     // Rule at src/isa/x64/inst.isle line 1078.
1195     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1196     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
1197     return Some(expr1_0);
1198 }
1199 
1200 // Generated as internal constructor for term put_in_xmm_mem_imm.
1201 pub fn constructor_put_in_xmm_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMemImm> {
1202     let pattern0_0 = arg0;
1203     // Rule at src/isa/x64/inst.isle line 1085.
1204     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1205     let expr1_0 = C::xmm_mem_imm_new(ctx, &expr0_0);
1206     return Some(expr1_0);
1207 }
1208 
1209 // Generated as internal constructor for term output_gpr.
1210 pub fn constructor_output_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<InstOutput> {
1211     let pattern0_0 = arg0;
1212     // Rule at src/isa/x64/inst.isle line 1090.
1213     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1214     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1215     return Some(expr1_0);
1216 }
1217 
1218 // Generated as internal constructor for term value_gprs.
1219 pub fn constructor_value_gprs<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> Option<ValueRegs> {
1220     let pattern0_0 = arg0;
1221     let pattern1_0 = arg1;
1222     // Rule at src/isa/x64/inst.isle line 1095.
1223     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1224     let expr1_0 = C::gpr_to_reg(ctx, pattern1_0);
1225     let expr2_0 = C::value_regs(ctx, expr0_0, expr1_0);
1226     return Some(expr2_0);
1227 }
1228 
1229 // Generated as internal constructor for term output_xmm.
1230 pub fn constructor_output_xmm<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<InstOutput> {
1231     let pattern0_0 = arg0;
1232     // Rule at src/isa/x64/inst.isle line 1100.
1233     let expr0_0 = C::xmm_to_reg(ctx, pattern0_0);
1234     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1235     return Some(expr1_0);
1236 }
1237 
1238 // Generated as internal constructor for term value_regs_get_gpr.
1239 pub fn constructor_value_regs_get_gpr<C: Context>(
1240     ctx: &mut C,
1241     arg0: ValueRegs,
1242     arg1: usize,
1243 ) -> Option<Gpr> {
1244     let pattern0_0 = arg0;
1245     let pattern1_0 = arg1;
1246     // Rule at src/isa/x64/inst.isle line 1107.
1247     let expr0_0 = C::value_regs_get(ctx, pattern0_0, pattern1_0);
1248     let expr1_0 = C::gpr_new(ctx, expr0_0);
1249     return Some(expr1_0);
1250 }
1251 
1252 // Generated as internal constructor for term lo_gpr.
1253 pub fn constructor_lo_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1254     let pattern0_0 = arg0;
1255     // Rule at src/isa/x64/inst.isle line 1120.
1256     let expr0_0 = constructor_lo_reg(ctx, pattern0_0)?;
1257     let expr1_0 = C::gpr_new(ctx, expr0_0);
1258     return Some(expr1_0);
1259 }
1260 
1261 // Generated as internal constructor for term sink_load_to_gpr_mem_imm.
1262 pub fn constructor_sink_load_to_gpr_mem_imm<C: Context>(
1263     ctx: &mut C,
1264     arg0: &SinkableLoad,
1265 ) -> Option<GprMemImm> {
1266     let pattern0_0 = arg0;
1267     // Rule at src/isa/x64/inst.isle line 1203.
1268     let expr0_0 = C::sink_load(ctx, pattern0_0);
1269     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1270     return Some(expr1_0);
1271 }
1272 
1273 // Generated as internal constructor for term extend_to_gpr.
1274 pub fn constructor_extend_to_gpr<C: Context>(
1275     ctx: &mut C,
1276     arg0: Value,
1277     arg1: Type,
1278     arg2: &ExtendKind,
1279 ) -> Option<Gpr> {
1280     let pattern0_0 = arg0;
1281     let pattern1_0 = C::value_type(ctx, pattern0_0);
1282     let pattern2_0 = arg1;
1283     if pattern2_0 == pattern1_0 {
1284         let pattern4_0 = arg2;
1285         // Rule at src/isa/x64/inst.isle line 1225.
1286         let expr0_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
1287         return Some(expr0_0);
1288     }
1289     let pattern3_0 = arg2;
1290     // Rule at src/isa/x64/inst.isle line 1228.
1291     let expr0_0 = C::ty_bits_u16(ctx, pattern1_0);
1292     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern2_0);
1293     let expr2_0 = constructor_operand_size_bits(ctx, &expr1_0)?;
1294     let expr3_0 = C::ext_mode(ctx, expr0_0, expr2_0);
1295     let expr4_0 = constructor_put_in_gpr_mem(ctx, pattern0_0)?;
1296     let expr5_0 = constructor_extend(ctx, pattern3_0, pattern2_0, &expr3_0, &expr4_0)?;
1297     return Some(expr5_0);
1298 }
1299 
1300 // Generated as internal constructor for term extend.
1301 pub fn constructor_extend<C: Context>(
1302     ctx: &mut C,
1303     arg0: &ExtendKind,
1304     arg1: Type,
1305     arg2: &ExtMode,
1306     arg3: &GprMem,
1307 ) -> Option<Gpr> {
1308     let pattern0_0 = arg0;
1309     match pattern0_0 {
1310         &ExtendKind::Sign => {
1311             let pattern2_0 = arg1;
1312             let pattern3_0 = arg2;
1313             let pattern4_0 = arg3;
1314             // Rule at src/isa/x64/inst.isle line 1248.
1315             let expr0_0 = constructor_x64_movsx(ctx, pattern3_0, pattern4_0)?;
1316             return Some(expr0_0);
1317         }
1318         &ExtendKind::Zero => {
1319             let pattern2_0 = arg1;
1320             let pattern3_0 = arg2;
1321             let pattern4_0 = arg3;
1322             // Rule at src/isa/x64/inst.isle line 1244.
1323             let expr0_0 = constructor_x64_movzx(ctx, pattern3_0, pattern4_0)?;
1324             return Some(expr0_0);
1325         }
1326         _ => {}
1327     }
1328     return None;
1329 }
1330 
1331 // Generated as internal constructor for term sse_xor_op.
1332 pub fn constructor_sse_xor_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1333     let pattern0_0 = arg0;
1334     if pattern0_0 == F32X4 {
1335         // Rule at src/isa/x64/inst.isle line 1255.
1336         let expr0_0 = SseOpcode::Xorps;
1337         return Some(expr0_0);
1338     }
1339     if pattern0_0 == F64X2 {
1340         // Rule at src/isa/x64/inst.isle line 1256.
1341         let expr0_0 = SseOpcode::Xorpd;
1342         return Some(expr0_0);
1343     }
1344     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1345         // Rule at src/isa/x64/inst.isle line 1257.
1346         let expr0_0 = SseOpcode::Pxor;
1347         return Some(expr0_0);
1348     }
1349     return None;
1350 }
1351 
1352 // Generated as internal constructor for term sse_xor.
1353 pub fn constructor_sse_xor<C: Context>(
1354     ctx: &mut C,
1355     arg0: Type,
1356     arg1: Xmm,
1357     arg2: &XmmMem,
1358 ) -> Option<Xmm> {
1359     let pattern0_0 = arg0;
1360     let pattern1_0 = arg1;
1361     let pattern2_0 = arg2;
1362     // Rule at src/isa/x64/inst.isle line 1261.
1363     let expr0_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
1364     let expr1_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1365     return Some(expr1_0);
1366 }
1367 
1368 // Generated as internal constructor for term sse_cmp_op.
1369 pub fn constructor_sse_cmp_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1370     let pattern0_0 = arg0;
1371     if pattern0_0 == F32X4 {
1372         // Rule at src/isa/x64/inst.isle line 1270.
1373         let expr0_0 = SseOpcode::Cmpps;
1374         return Some(expr0_0);
1375     }
1376     if pattern0_0 == F64X2 {
1377         // Rule at src/isa/x64/inst.isle line 1271.
1378         let expr0_0 = SseOpcode::Cmppd;
1379         return Some(expr0_0);
1380     }
1381     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1382         if pattern1_0 == 8 {
1383             if pattern1_1 == 16 {
1384                 // Rule at src/isa/x64/inst.isle line 1266.
1385                 let expr0_0 = SseOpcode::Pcmpeqb;
1386                 return Some(expr0_0);
1387             }
1388         }
1389         if pattern1_0 == 16 {
1390             if pattern1_1 == 8 {
1391                 // Rule at src/isa/x64/inst.isle line 1267.
1392                 let expr0_0 = SseOpcode::Pcmpeqw;
1393                 return Some(expr0_0);
1394             }
1395         }
1396         if pattern1_0 == 32 {
1397             if pattern1_1 == 4 {
1398                 // Rule at src/isa/x64/inst.isle line 1268.
1399                 let expr0_0 = SseOpcode::Pcmpeqd;
1400                 return Some(expr0_0);
1401             }
1402         }
1403         if pattern1_0 == 64 {
1404             if pattern1_1 == 2 {
1405                 // Rule at src/isa/x64/inst.isle line 1269.
1406                 let expr0_0 = SseOpcode::Pcmpeqq;
1407                 return Some(expr0_0);
1408             }
1409         }
1410     }
1411     return None;
1412 }
1413 
1414 // Generated as internal constructor for term vector_all_ones.
1415 pub fn constructor_vector_all_ones<C: Context>(ctx: &mut C, arg0: Type) -> Option<Xmm> {
1416     let pattern0_0 = arg0;
1417     // Rule at src/isa/x64/inst.isle line 1285.
1418     let expr0_0 = C::temp_writable_xmm(ctx);
1419     let expr1_0: Type = I32X4;
1420     let expr2_0 = constructor_sse_cmp_op(ctx, expr1_0)?;
1421     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1422     let expr4_0 = constructor_writable_xmm_to_xmm_mem(ctx, expr0_0)?;
1423     let expr5_0 = MInst::XmmRmR {
1424         op: expr2_0,
1425         src1: expr3_0,
1426         src2: expr4_0,
1427         dst: expr0_0,
1428     };
1429     let expr6_0 = C::emit(ctx, &expr5_0);
1430     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1431     return Some(expr7_0);
1432 }
1433 
1434 // Generated as internal constructor for term make_i64x2_from_lanes.
1435 pub fn constructor_make_i64x2_from_lanes<C: Context>(
1436     ctx: &mut C,
1437     arg0: &GprMem,
1438     arg1: &GprMem,
1439 ) -> Option<Xmm> {
1440     let pattern0_0 = arg0;
1441     let pattern1_0 = arg1;
1442     // Rule at src/isa/x64/inst.isle line 1295.
1443     let expr0_0 = C::temp_writable_xmm(ctx);
1444     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
1445     let expr2_0 = MInst::XmmUninitializedValue { dst: expr0_0 };
1446     let expr3_0 = C::emit(ctx, &expr2_0);
1447     let expr4_0 = SseOpcode::Pinsrd;
1448     let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0);
1449     let expr6_0 = C::gpr_mem_to_reg_mem(ctx, pattern0_0);
1450     let expr7_0: u8 = 0;
1451     let expr8_0 = OperandSize::Size64;
1452     let expr9_0 = MInst::XmmRmRImm {
1453         op: expr4_0,
1454         src1: expr5_0,
1455         src2: expr6_0,
1456         dst: expr1_0,
1457         imm: expr7_0,
1458         size: expr8_0,
1459     };
1460     let expr10_0 = C::emit(ctx, &expr9_0);
1461     let expr11_0 = SseOpcode::Pinsrd;
1462     let expr12_0 = C::writable_reg_to_reg(ctx, expr1_0);
1463     let expr13_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
1464     let expr14_0: u8 = 1;
1465     let expr15_0 = OperandSize::Size64;
1466     let expr16_0 = MInst::XmmRmRImm {
1467         op: expr11_0,
1468         src1: expr12_0,
1469         src2: expr13_0,
1470         dst: expr1_0,
1471         imm: expr14_0,
1472         size: expr15_0,
1473     };
1474     let expr17_0 = C::emit(ctx, &expr16_0);
1475     let expr18_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1476     return Some(expr18_0);
1477 }
1478 
1479 // Generated as internal constructor for term mov_rmi_to_xmm.
1480 pub fn constructor_mov_rmi_to_xmm<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> Option<XmmMemImm> {
1481     let pattern0_0 = arg0;
1482     match pattern0_0 {
1483         &RegMemImm::Imm { simm32: pattern1_0 } => {
1484             // Rule at src/isa/x64/inst.isle line 1316.
1485             let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0);
1486             return Some(expr0_0);
1487         }
1488         &RegMemImm::Reg { reg: pattern1_0 } => {
1489             // Rule at src/isa/x64/inst.isle line 1317.
1490             let expr0_0 = SseOpcode::Movd;
1491             let expr1_0 = C::reg_to_gpr_mem(ctx, pattern1_0);
1492             let expr2_0 = OperandSize::Size32;
1493             let expr3_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr1_0, &expr2_0)?;
1494             let expr4_0 = C::xmm_to_xmm_mem_imm(ctx, expr3_0);
1495             return Some(expr4_0);
1496         }
1497         &RegMemImm::Mem {
1498             addr: ref pattern1_0,
1499         } => {
1500             // Rule at src/isa/x64/inst.isle line 1315.
1501             let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0);
1502             return Some(expr0_0);
1503         }
1504         _ => {}
1505     }
1506     return None;
1507 }
1508 
1509 // Generated as internal constructor for term x64_load.
1510 pub fn constructor_x64_load<C: Context>(
1511     ctx: &mut C,
1512     arg0: Type,
1513     arg1: &SyntheticAmode,
1514     arg2: &ExtKind,
1515 ) -> Option<Reg> {
1516     let pattern0_0 = arg0;
1517     if pattern0_0 == I64 {
1518         let pattern2_0 = arg1;
1519         let pattern3_0 = arg2;
1520         // Rule at src/isa/x64/inst.isle line 1331.
1521         let expr0_0 = C::temp_writable_gpr(ctx);
1522         let expr1_0 = MInst::Mov64MR {
1523             src: pattern2_0.clone(),
1524             dst: expr0_0,
1525         };
1526         let expr2_0 = C::emit(ctx, &expr1_0);
1527         let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1528         return Some(expr3_0);
1529     }
1530     if pattern0_0 == F32 {
1531         let pattern2_0 = arg1;
1532         let pattern3_0 = arg2;
1533         // Rule at src/isa/x64/inst.isle line 1336.
1534         let expr0_0 = SseOpcode::Movss;
1535         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1536         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1537         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1538         return Some(expr3_0);
1539     }
1540     if pattern0_0 == F64 {
1541         let pattern2_0 = arg1;
1542         let pattern3_0 = arg2;
1543         // Rule at src/isa/x64/inst.isle line 1340.
1544         let expr0_0 = SseOpcode::Movsd;
1545         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1546         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1547         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1548         return Some(expr3_0);
1549     }
1550     if pattern0_0 == F32X4 {
1551         let pattern2_0 = arg1;
1552         let pattern3_0 = arg2;
1553         // Rule at src/isa/x64/inst.isle line 1344.
1554         let expr0_0 = SseOpcode::Movups;
1555         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1556         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1557         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1558         return Some(expr3_0);
1559     }
1560     if pattern0_0 == F64X2 {
1561         let pattern2_0 = arg1;
1562         let pattern3_0 = arg2;
1563         // Rule at src/isa/x64/inst.isle line 1348.
1564         let expr0_0 = SseOpcode::Movupd;
1565         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1566         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1567         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1568         return Some(expr3_0);
1569     }
1570     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1571         let pattern2_0 = arg1;
1572         let pattern3_0 = arg2;
1573         // Rule at src/isa/x64/inst.isle line 1352.
1574         let expr0_0 = SseOpcode::Movdqu;
1575         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1576         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1577         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1578         return Some(expr3_0);
1579     }
1580     if let Some(pattern1_0) = C::fits_in_32(ctx, pattern0_0) {
1581         let pattern2_0 = arg1;
1582         let pattern3_0 = arg2;
1583         if let &ExtKind::SignExtend = pattern3_0 {
1584             // Rule at src/isa/x64/inst.isle line 1327.
1585             let expr0_0 = C::ty_bytes(ctx, pattern1_0);
1586             let expr1_0: u16 = 8;
1587             let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
1588             let expr3_0 = constructor_synthetic_amode_to_gpr_mem(ctx, pattern2_0)?;
1589             let expr4_0 = constructor_x64_movsx(ctx, &expr2_0, &expr3_0)?;
1590             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
1591             return Some(expr5_0);
1592         }
1593     }
1594     return None;
1595 }
1596 
1597 // Generated as internal constructor for term x64_mov.
1598 pub fn constructor_x64_mov<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<Reg> {
1599     let pattern0_0 = arg0;
1600     // Rule at src/isa/x64/inst.isle line 1357.
1601     let expr0_0 = C::temp_writable_gpr(ctx);
1602     let expr1_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
1603     let expr2_0 = MInst::Mov64MR {
1604         src: expr1_0,
1605         dst: expr0_0,
1606     };
1607     let expr3_0 = C::emit(ctx, &expr2_0);
1608     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1609     return Some(expr4_0);
1610 }
1611 
1612 // Generated as internal constructor for term x64_movzx.
1613 pub fn constructor_x64_movzx<C: Context>(
1614     ctx: &mut C,
1615     arg0: &ExtMode,
1616     arg1: &GprMem,
1617 ) -> Option<Gpr> {
1618     let pattern0_0 = arg0;
1619     let pattern1_0 = arg1;
1620     // Rule at src/isa/x64/inst.isle line 1363.
1621     let expr0_0 = C::temp_writable_gpr(ctx);
1622     let expr1_0 = MInst::MovzxRmR {
1623         ext_mode: pattern0_0.clone(),
1624         src: pattern1_0.clone(),
1625         dst: expr0_0,
1626     };
1627     let expr2_0 = C::emit(ctx, &expr1_0);
1628     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1629     return Some(expr3_0);
1630 }
1631 
1632 // Generated as internal constructor for term x64_movsx.
1633 pub fn constructor_x64_movsx<C: Context>(
1634     ctx: &mut C,
1635     arg0: &ExtMode,
1636     arg1: &GprMem,
1637 ) -> Option<Gpr> {
1638     let pattern0_0 = arg0;
1639     let pattern1_0 = arg1;
1640     // Rule at src/isa/x64/inst.isle line 1369.
1641     let expr0_0 = C::temp_writable_gpr(ctx);
1642     let expr1_0 = MInst::MovsxRmR {
1643         ext_mode: pattern0_0.clone(),
1644         src: pattern1_0.clone(),
1645         dst: expr0_0,
1646     };
1647     let expr2_0 = C::emit(ctx, &expr1_0);
1648     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1649     return Some(expr3_0);
1650 }
1651 
1652 // Generated as internal constructor for term x64_movss_load.
1653 pub fn constructor_x64_movss_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1654     let pattern0_0 = arg0;
1655     // Rule at src/isa/x64/inst.isle line 1375.
1656     let expr0_0 = SseOpcode::Movss;
1657     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1658     return Some(expr1_0);
1659 }
1660 
1661 // Generated as internal constructor for term x64_movsd_load.
1662 pub fn constructor_x64_movsd_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1663     let pattern0_0 = arg0;
1664     // Rule at src/isa/x64/inst.isle line 1379.
1665     let expr0_0 = SseOpcode::Movsd;
1666     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1667     return Some(expr1_0);
1668 }
1669 
1670 // Generated as internal constructor for term x64_movups.
1671 pub fn constructor_x64_movups<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1672     let pattern0_0 = arg0;
1673     // Rule at src/isa/x64/inst.isle line 1383.
1674     let expr0_0 = SseOpcode::Movups;
1675     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1676     return Some(expr1_0);
1677 }
1678 
1679 // Generated as internal constructor for term x64_movupd.
1680 pub fn constructor_x64_movupd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1681     let pattern0_0 = arg0;
1682     // Rule at src/isa/x64/inst.isle line 1387.
1683     let expr0_0 = SseOpcode::Movupd;
1684     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1685     return Some(expr1_0);
1686 }
1687 
1688 // Generated as internal constructor for term x64_movdqu.
1689 pub fn constructor_x64_movdqu<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1690     let pattern0_0 = arg0;
1691     // Rule at src/isa/x64/inst.isle line 1391.
1692     let expr0_0 = SseOpcode::Movdqu;
1693     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1694     return Some(expr1_0);
1695 }
1696 
1697 // Generated as internal constructor for term x64_pmovsxbw.
1698 pub fn constructor_x64_pmovsxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1699     let pattern0_0 = arg0;
1700     // Rule at src/isa/x64/inst.isle line 1395.
1701     let expr0_0 = SseOpcode::Pmovsxbw;
1702     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1703     return Some(expr1_0);
1704 }
1705 
1706 // Generated as internal constructor for term x64_pmovzxbw.
1707 pub fn constructor_x64_pmovzxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1708     let pattern0_0 = arg0;
1709     // Rule at src/isa/x64/inst.isle line 1399.
1710     let expr0_0 = SseOpcode::Pmovzxbw;
1711     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1712     return Some(expr1_0);
1713 }
1714 
1715 // Generated as internal constructor for term x64_pmovsxwd.
1716 pub fn constructor_x64_pmovsxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1717     let pattern0_0 = arg0;
1718     // Rule at src/isa/x64/inst.isle line 1403.
1719     let expr0_0 = SseOpcode::Pmovsxwd;
1720     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1721     return Some(expr1_0);
1722 }
1723 
1724 // Generated as internal constructor for term x64_pmovzxwd.
1725 pub fn constructor_x64_pmovzxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1726     let pattern0_0 = arg0;
1727     // Rule at src/isa/x64/inst.isle line 1407.
1728     let expr0_0 = SseOpcode::Pmovzxwd;
1729     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1730     return Some(expr1_0);
1731 }
1732 
1733 // Generated as internal constructor for term x64_pmovsxdq.
1734 pub fn constructor_x64_pmovsxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1735     let pattern0_0 = arg0;
1736     // Rule at src/isa/x64/inst.isle line 1411.
1737     let expr0_0 = SseOpcode::Pmovsxdq;
1738     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1739     return Some(expr1_0);
1740 }
1741 
1742 // Generated as internal constructor for term x64_pmovzxdq.
1743 pub fn constructor_x64_pmovzxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1744     let pattern0_0 = arg0;
1745     // Rule at src/isa/x64/inst.isle line 1415.
1746     let expr0_0 = SseOpcode::Pmovzxdq;
1747     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1748     return Some(expr1_0);
1749 }
1750 
1751 // Generated as internal constructor for term x64_movrm.
1752 pub fn constructor_x64_movrm<C: Context>(
1753     ctx: &mut C,
1754     arg0: Type,
1755     arg1: &SyntheticAmode,
1756     arg2: Gpr,
1757 ) -> Option<SideEffectNoResult> {
1758     let pattern0_0 = arg0;
1759     let pattern1_0 = arg1;
1760     let pattern2_0 = arg2;
1761     // Rule at src/isa/x64/inst.isle line 1419.
1762     let expr0_0 = C::raw_operand_size_of_type(ctx, pattern0_0);
1763     let expr1_0 = MInst::MovRM {
1764         size: expr0_0,
1765         src: pattern2_0,
1766         dst: pattern1_0.clone(),
1767     };
1768     let expr2_0 = SideEffectNoResult::Inst { inst: expr1_0 };
1769     return Some(expr2_0);
1770 }
1771 
1772 // Generated as internal constructor for term x64_xmm_movrm.
1773 pub fn constructor_x64_xmm_movrm<C: Context>(
1774     ctx: &mut C,
1775     arg0: &SseOpcode,
1776     arg1: &SyntheticAmode,
1777     arg2: Xmm,
1778 ) -> Option<SideEffectNoResult> {
1779     let pattern0_0 = arg0;
1780     let pattern1_0 = arg1;
1781     let pattern2_0 = arg2;
1782     // Rule at src/isa/x64/inst.isle line 1424.
1783     let expr0_0 = C::xmm_to_reg(ctx, pattern2_0);
1784     let expr1_0 = MInst::XmmMovRM {
1785         op: pattern0_0.clone(),
1786         src: expr0_0,
1787         dst: pattern1_0.clone(),
1788     };
1789     let expr2_0 = SideEffectNoResult::Inst { inst: expr1_0 };
1790     return Some(expr2_0);
1791 }
1792 
1793 // Generated as internal constructor for term x64_xmm_load_const.
1794 pub fn constructor_x64_xmm_load_const<C: Context>(
1795     ctx: &mut C,
1796     arg0: Type,
1797     arg1: VCodeConstant,
1798 ) -> Option<Xmm> {
1799     let pattern0_0 = arg0;
1800     let pattern1_0 = arg1;
1801     // Rule at src/isa/x64/inst.isle line 1429.
1802     let expr0_0 = C::temp_writable_xmm(ctx);
1803     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
1804     let expr2_0 = MInst::XmmLoadConst {
1805         src: pattern1_0,
1806         dst: expr1_0,
1807         ty: pattern0_0,
1808     };
1809     let expr3_0 = C::emit(ctx, &expr2_0);
1810     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1811     return Some(expr4_0);
1812 }
1813 
1814 // Generated as internal constructor for term alu_rmi_r.
1815 pub fn constructor_alu_rmi_r<C: Context>(
1816     ctx: &mut C,
1817     arg0: Type,
1818     arg1: &AluRmiROpcode,
1819     arg2: Gpr,
1820     arg3: &GprMemImm,
1821 ) -> Option<Gpr> {
1822     let pattern0_0 = arg0;
1823     let pattern1_0 = arg1;
1824     let pattern2_0 = arg2;
1825     let pattern3_0 = arg3;
1826     // Rule at src/isa/x64/inst.isle line 1442.
1827     let expr0_0 = C::temp_writable_gpr(ctx);
1828     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1829     let expr2_0 = MInst::AluRmiR {
1830         size: expr1_0,
1831         op: pattern1_0.clone(),
1832         src1: pattern2_0,
1833         src2: pattern3_0.clone(),
1834         dst: expr0_0,
1835     };
1836     let expr3_0 = C::emit(ctx, &expr2_0);
1837     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1838     return Some(expr4_0);
1839 }
1840 
1841 // Generated as internal constructor for term x64_add.
1842 pub fn constructor_x64_add<C: Context>(
1843     ctx: &mut C,
1844     arg0: Type,
1845     arg1: Gpr,
1846     arg2: &GprMemImm,
1847 ) -> Option<Gpr> {
1848     let pattern0_0 = arg0;
1849     let pattern1_0 = arg1;
1850     let pattern2_0 = arg2;
1851     // Rule at src/isa/x64/inst.isle line 1450.
1852     let expr0_0 = AluRmiROpcode::Add;
1853     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1854     return Some(expr1_0);
1855 }
1856 
1857 // Generated as internal constructor for term x64_add_with_flags_paired.
1858 pub fn constructor_x64_add_with_flags_paired<C: Context>(
1859     ctx: &mut C,
1860     arg0: Type,
1861     arg1: Gpr,
1862     arg2: &GprMemImm,
1863 ) -> Option<ProducesFlags> {
1864     let pattern0_0 = arg0;
1865     let pattern1_0 = arg1;
1866     let pattern2_0 = arg2;
1867     // Rule at src/isa/x64/inst.isle line 1458.
1868     let expr0_0 = C::temp_writable_gpr(ctx);
1869     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1870     let expr2_0 = AluRmiROpcode::Add;
1871     let expr3_0 = MInst::AluRmiR {
1872         size: expr1_0,
1873         op: expr2_0,
1874         src1: pattern1_0,
1875         src2: pattern2_0.clone(),
1876         dst: expr0_0,
1877     };
1878     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1879     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
1880         inst: expr3_0,
1881         result: expr4_0,
1882     };
1883     return Some(expr5_0);
1884 }
1885 
1886 // Generated as internal constructor for term x64_adc_paired.
1887 pub fn constructor_x64_adc_paired<C: Context>(
1888     ctx: &mut C,
1889     arg0: Type,
1890     arg1: Gpr,
1891     arg2: &GprMemImm,
1892 ) -> Option<ConsumesFlags> {
1893     let pattern0_0 = arg0;
1894     let pattern1_0 = arg1;
1895     let pattern2_0 = arg2;
1896     // Rule at src/isa/x64/inst.isle line 1470.
1897     let expr0_0 = C::temp_writable_gpr(ctx);
1898     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1899     let expr2_0 = AluRmiROpcode::Adc;
1900     let expr3_0 = MInst::AluRmiR {
1901         size: expr1_0,
1902         op: expr2_0,
1903         src1: pattern1_0,
1904         src2: pattern2_0.clone(),
1905         dst: expr0_0,
1906     };
1907     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1908     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
1909         inst: expr3_0,
1910         result: expr4_0,
1911     };
1912     return Some(expr5_0);
1913 }
1914 
1915 // Generated as internal constructor for term x64_sub.
1916 pub fn constructor_x64_sub<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 1482.
1926     let expr0_0 = AluRmiROpcode::Sub;
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_sub_with_flags_paired.
1932 pub fn constructor_x64_sub_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 1490.
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::Sub;
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 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1953     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
1954         inst: expr3_0,
1955         result: expr4_0,
1956     };
1957     return Some(expr5_0);
1958 }
1959 
1960 // Generated as internal constructor for term x64_sbb_paired.
1961 pub fn constructor_x64_sbb_paired<C: Context>(
1962     ctx: &mut C,
1963     arg0: Type,
1964     arg1: Gpr,
1965     arg2: &GprMemImm,
1966 ) -> Option<ConsumesFlags> {
1967     let pattern0_0 = arg0;
1968     let pattern1_0 = arg1;
1969     let pattern2_0 = arg2;
1970     // Rule at src/isa/x64/inst.isle line 1502.
1971     let expr0_0 = C::temp_writable_gpr(ctx);
1972     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1973     let expr2_0 = AluRmiROpcode::Sbb;
1974     let expr3_0 = MInst::AluRmiR {
1975         size: expr1_0,
1976         op: expr2_0,
1977         src1: pattern1_0,
1978         src2: pattern2_0.clone(),
1979         dst: expr0_0,
1980     };
1981     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1982     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
1983         inst: expr3_0,
1984         result: expr4_0,
1985     };
1986     return Some(expr5_0);
1987 }
1988 
1989 // Generated as internal constructor for term x64_mul.
1990 pub fn constructor_x64_mul<C: Context>(
1991     ctx: &mut C,
1992     arg0: Type,
1993     arg1: Gpr,
1994     arg2: &GprMemImm,
1995 ) -> Option<Gpr> {
1996     let pattern0_0 = arg0;
1997     let pattern1_0 = arg1;
1998     let pattern2_0 = arg2;
1999     // Rule at src/isa/x64/inst.isle line 1514.
2000     let expr0_0 = AluRmiROpcode::Mul;
2001     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2002     return Some(expr1_0);
2003 }
2004 
2005 // Generated as internal constructor for term x64_and.
2006 pub fn constructor_x64_and<C: Context>(
2007     ctx: &mut C,
2008     arg0: Type,
2009     arg1: Gpr,
2010     arg2: &GprMemImm,
2011 ) -> Option<Gpr> {
2012     let pattern0_0 = arg0;
2013     let pattern1_0 = arg1;
2014     let pattern2_0 = arg2;
2015     // Rule at src/isa/x64/inst.isle line 1522.
2016     let expr0_0 = AluRmiROpcode::And;
2017     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2018     return Some(expr1_0);
2019 }
2020 
2021 // Generated as internal constructor for term x64_and_with_flags_paired.
2022 pub fn constructor_x64_and_with_flags_paired<C: Context>(
2023     ctx: &mut C,
2024     arg0: Type,
2025     arg1: Gpr,
2026     arg2: &GprMemImm,
2027 ) -> Option<ProducesFlags> {
2028     let pattern0_0 = arg0;
2029     let pattern1_0 = arg1;
2030     let pattern2_0 = arg2;
2031     // Rule at src/isa/x64/inst.isle line 1529.
2032     let expr0_0 = C::temp_writable_gpr(ctx);
2033     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2034     let expr2_0 = AluRmiROpcode::And;
2035     let expr3_0 = MInst::AluRmiR {
2036         size: expr1_0,
2037         op: expr2_0,
2038         src1: pattern1_0,
2039         src2: pattern2_0.clone(),
2040         dst: expr0_0,
2041     };
2042     let expr4_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr3_0 };
2043     return Some(expr4_0);
2044 }
2045 
2046 // Generated as internal constructor for term x64_or.
2047 pub fn constructor_x64_or<C: Context>(
2048     ctx: &mut C,
2049     arg0: Type,
2050     arg1: Gpr,
2051     arg2: &GprMemImm,
2052 ) -> Option<Gpr> {
2053     let pattern0_0 = arg0;
2054     let pattern1_0 = arg1;
2055     let pattern2_0 = arg2;
2056     // Rule at src/isa/x64/inst.isle line 1540.
2057     let expr0_0 = AluRmiROpcode::Or;
2058     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2059     return Some(expr1_0);
2060 }
2061 
2062 // Generated as internal constructor for term x64_xor.
2063 pub fn constructor_x64_xor<C: Context>(
2064     ctx: &mut C,
2065     arg0: Type,
2066     arg1: Gpr,
2067     arg2: &GprMemImm,
2068 ) -> Option<Gpr> {
2069     let pattern0_0 = arg0;
2070     let pattern1_0 = arg1;
2071     let pattern2_0 = arg2;
2072     // Rule at src/isa/x64/inst.isle line 1548.
2073     let expr0_0 = AluRmiROpcode::Xor;
2074     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2075     return Some(expr1_0);
2076 }
2077 
2078 // Generated as internal constructor for term imm.
2079 pub fn constructor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: u64) -> Option<Reg> {
2080     let pattern0_0 = arg0;
2081     if pattern0_0 == I64 {
2082         let pattern2_0 = arg1;
2083         if let Some(pattern3_0) = C::nonzero_u64_fits_in_u32(ctx, pattern2_0) {
2084             // Rule at src/isa/x64/inst.isle line 1588.
2085             let expr0_0 = C::temp_writable_gpr(ctx);
2086             let expr1_0 = OperandSize::Size32;
2087             let expr2_0 = MInst::Imm {
2088                 dst_size: expr1_0,
2089                 simm64: pattern3_0,
2090                 dst: expr0_0,
2091             };
2092             let expr3_0 = C::emit(ctx, &expr2_0);
2093             let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2094             return Some(expr4_0);
2095         }
2096     }
2097     if pattern0_0 == F32 {
2098         let pattern2_0 = arg1;
2099         if pattern2_0 == 0 {
2100             // Rule at src/isa/x64/inst.isle line 1617.
2101             let expr0_0 = C::temp_writable_xmm(ctx);
2102             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2103             let expr2_0 = SseOpcode::Xorps;
2104             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2105             let expr4_0 = MInst::XmmRmR {
2106                 op: expr2_0,
2107                 src1: expr1_0,
2108                 src2: expr3_0,
2109                 dst: expr0_0,
2110             };
2111             let expr5_0 = C::emit(ctx, &expr4_0);
2112             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2113             return Some(expr6_0);
2114         }
2115         // Rule at src/isa/x64/inst.isle line 1565.
2116         let expr0_0 = SseOpcode::Movd;
2117         let expr1_0: Type = I32;
2118         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2119         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2120         let expr4_0 = OperandSize::Size32;
2121         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2122         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2123         return Some(expr6_0);
2124     }
2125     if pattern0_0 == F64 {
2126         let pattern2_0 = arg1;
2127         if pattern2_0 == 0 {
2128             // Rule at src/isa/x64/inst.isle line 1629.
2129             let expr0_0 = C::temp_writable_xmm(ctx);
2130             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2131             let expr2_0 = SseOpcode::Xorpd;
2132             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2133             let expr4_0 = MInst::XmmRmR {
2134                 op: expr2_0,
2135                 src1: expr1_0,
2136                 src2: expr3_0,
2137                 dst: expr0_0,
2138             };
2139             let expr5_0 = C::emit(ctx, &expr4_0);
2140             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2141             return Some(expr6_0);
2142         }
2143         // Rule at src/isa/x64/inst.isle line 1571.
2144         let expr0_0 = SseOpcode::Movq;
2145         let expr1_0: Type = I64;
2146         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2147         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2148         let expr4_0 = OperandSize::Size64;
2149         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2150         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2151         return Some(expr6_0);
2152     }
2153     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
2154         let pattern2_0 = arg1;
2155         if pattern2_0 == 0 {
2156             // Rule at src/isa/x64/inst.isle line 1607.
2157             let expr0_0 = C::temp_writable_xmm(ctx);
2158             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2159             let expr2_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
2160             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2161             let expr4_0 = MInst::XmmRmR {
2162                 op: expr2_0,
2163                 src1: expr1_0,
2164                 src2: expr3_0,
2165                 dst: expr0_0,
2166             };
2167             let expr5_0 = C::emit(ctx, &expr4_0);
2168             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2169             return Some(expr6_0);
2170         }
2171     }
2172     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
2173         let pattern2_0 = arg1;
2174         if pattern2_0 == 0 {
2175             // Rule at src/isa/x64/inst.isle line 1594.
2176             let expr0_0 = C::temp_writable_gpr(ctx);
2177             let expr1_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2178             let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2179             let expr3_0 = AluRmiROpcode::Xor;
2180             let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
2181             let expr5_0 = MInst::AluRmiR {
2182                 size: expr2_0,
2183                 op: expr3_0,
2184                 src1: expr1_0,
2185                 src2: expr4_0,
2186                 dst: expr0_0,
2187             };
2188             let expr6_0 = C::emit(ctx, &expr5_0);
2189             let expr7_0 = C::gpr_to_reg(ctx, expr1_0);
2190             return Some(expr7_0);
2191         }
2192         // Rule at src/isa/x64/inst.isle line 1558.
2193         let expr0_0 = C::temp_writable_gpr(ctx);
2194         let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2195         let expr2_0 = MInst::Imm {
2196             dst_size: expr1_0,
2197             simm64: pattern2_0,
2198             dst: expr0_0,
2199         };
2200         let expr3_0 = C::emit(ctx, &expr2_0);
2201         let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2202         return Some(expr4_0);
2203     }
2204     return None;
2205 }
2206 
2207 // Generated as internal constructor for term imm_i64.
2208 pub fn constructor_imm_i64<C: Context>(ctx: &mut C, arg0: Type, arg1: i64) -> Option<Reg> {
2209     let pattern0_0 = arg0;
2210     let pattern1_0 = arg1;
2211     // Rule at src/isa/x64/inst.isle line 1580.
2212     let expr0_0 = C::i64_as_u64(ctx, pattern1_0);
2213     let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
2214     return Some(expr1_0);
2215 }
2216 
2217 // Generated as internal constructor for term shift_r.
2218 pub fn constructor_shift_r<C: Context>(
2219     ctx: &mut C,
2220     arg0: Type,
2221     arg1: &ShiftKind,
2222     arg2: Gpr,
2223     arg3: &Imm8Gpr,
2224 ) -> Option<Gpr> {
2225     let pattern0_0 = arg0;
2226     let pattern1_0 = arg1;
2227     let pattern2_0 = arg2;
2228     let pattern3_0 = arg3;
2229     // Rule at src/isa/x64/inst.isle line 1642.
2230     let expr0_0 = C::temp_writable_gpr(ctx);
2231     let expr1_0 = C::raw_operand_size_of_type(ctx, pattern0_0);
2232     let expr2_0 = MInst::ShiftR {
2233         size: expr1_0,
2234         kind: pattern1_0.clone(),
2235         src: pattern2_0,
2236         num_bits: pattern3_0.clone(),
2237         dst: expr0_0,
2238     };
2239     let expr3_0 = C::emit(ctx, &expr2_0);
2240     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2241     return Some(expr4_0);
2242 }
2243 
2244 // Generated as internal constructor for term x64_rotl.
2245 pub fn constructor_x64_rotl<C: Context>(
2246     ctx: &mut C,
2247     arg0: Type,
2248     arg1: Gpr,
2249     arg2: &Imm8Gpr,
2250 ) -> Option<Gpr> {
2251     let pattern0_0 = arg0;
2252     let pattern1_0 = arg1;
2253     let pattern2_0 = arg2;
2254     // Rule at src/isa/x64/inst.isle line 1652.
2255     let expr0_0 = ShiftKind::RotateLeft;
2256     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2257     return Some(expr1_0);
2258 }
2259 
2260 // Generated as internal constructor for term x64_rotr.
2261 pub fn constructor_x64_rotr<C: Context>(
2262     ctx: &mut C,
2263     arg0: Type,
2264     arg1: Gpr,
2265     arg2: &Imm8Gpr,
2266 ) -> Option<Gpr> {
2267     let pattern0_0 = arg0;
2268     let pattern1_0 = arg1;
2269     let pattern2_0 = arg2;
2270     // Rule at src/isa/x64/inst.isle line 1657.
2271     let expr0_0 = ShiftKind::RotateRight;
2272     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2273     return Some(expr1_0);
2274 }
2275 
2276 // Generated as internal constructor for term x64_shl.
2277 pub fn constructor_x64_shl<C: Context>(
2278     ctx: &mut C,
2279     arg0: Type,
2280     arg1: Gpr,
2281     arg2: &Imm8Gpr,
2282 ) -> Option<Gpr> {
2283     let pattern0_0 = arg0;
2284     let pattern1_0 = arg1;
2285     let pattern2_0 = arg2;
2286     // Rule at src/isa/x64/inst.isle line 1662.
2287     let expr0_0 = ShiftKind::ShiftLeft;
2288     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2289     return Some(expr1_0);
2290 }
2291 
2292 // Generated as internal constructor for term x64_shr.
2293 pub fn constructor_x64_shr<C: Context>(
2294     ctx: &mut C,
2295     arg0: Type,
2296     arg1: Gpr,
2297     arg2: &Imm8Gpr,
2298 ) -> Option<Gpr> {
2299     let pattern0_0 = arg0;
2300     let pattern1_0 = arg1;
2301     let pattern2_0 = arg2;
2302     // Rule at src/isa/x64/inst.isle line 1667.
2303     let expr0_0 = ShiftKind::ShiftRightLogical;
2304     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2305     return Some(expr1_0);
2306 }
2307 
2308 // Generated as internal constructor for term x64_sar.
2309 pub fn constructor_x64_sar<C: Context>(
2310     ctx: &mut C,
2311     arg0: Type,
2312     arg1: Gpr,
2313     arg2: &Imm8Gpr,
2314 ) -> Option<Gpr> {
2315     let pattern0_0 = arg0;
2316     let pattern1_0 = arg1;
2317     let pattern2_0 = arg2;
2318     // Rule at src/isa/x64/inst.isle line 1672.
2319     let expr0_0 = ShiftKind::ShiftRightArithmetic;
2320     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2321     return Some(expr1_0);
2322 }
2323 
2324 // Generated as internal constructor for term cmp_rmi_r.
2325 pub fn constructor_cmp_rmi_r<C: Context>(
2326     ctx: &mut C,
2327     arg0: &OperandSize,
2328     arg1: &CmpOpcode,
2329     arg2: &GprMemImm,
2330     arg3: Gpr,
2331 ) -> Option<ProducesFlags> {
2332     let pattern0_0 = arg0;
2333     let pattern1_0 = arg1;
2334     let pattern2_0 = arg2;
2335     let pattern3_0 = arg3;
2336     // Rule at src/isa/x64/inst.isle line 1677.
2337     let expr0_0 = MInst::CmpRmiR {
2338         size: pattern0_0.clone(),
2339         opcode: pattern1_0.clone(),
2340         src: pattern2_0.clone(),
2341         dst: pattern3_0,
2342     };
2343     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2344     return Some(expr1_0);
2345 }
2346 
2347 // Generated as internal constructor for term x64_cmp.
2348 pub fn constructor_x64_cmp<C: Context>(
2349     ctx: &mut C,
2350     arg0: &OperandSize,
2351     arg1: &GprMemImm,
2352     arg2: Gpr,
2353 ) -> Option<ProducesFlags> {
2354     let pattern0_0 = arg0;
2355     let pattern1_0 = arg1;
2356     let pattern2_0 = arg2;
2357     // Rule at src/isa/x64/inst.isle line 1686.
2358     let expr0_0 = CmpOpcode::Cmp;
2359     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2360     return Some(expr1_0);
2361 }
2362 
2363 // Generated as internal constructor for term x64_cmp_imm.
2364 pub fn constructor_x64_cmp_imm<C: Context>(
2365     ctx: &mut C,
2366     arg0: &OperandSize,
2367     arg1: u32,
2368     arg2: Gpr,
2369 ) -> Option<ProducesFlags> {
2370     let pattern0_0 = arg0;
2371     let pattern1_0 = arg1;
2372     let pattern2_0 = arg2;
2373     // Rule at src/isa/x64/inst.isle line 1691.
2374     let expr0_0 = CmpOpcode::Cmp;
2375     let expr1_0 = RegMemImm::Imm { simm32: pattern1_0 };
2376     let expr2_0 = C::gpr_mem_imm_new(ctx, &expr1_0);
2377     let expr3_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, &expr2_0, pattern2_0)?;
2378     return Some(expr3_0);
2379 }
2380 
2381 // Generated as internal constructor for term xmm_cmp_rm_r.
2382 pub fn constructor_xmm_cmp_rm_r<C: Context>(
2383     ctx: &mut C,
2384     arg0: &SseOpcode,
2385     arg1: &XmmMem,
2386     arg2: Xmm,
2387 ) -> Option<ProducesFlags> {
2388     let pattern0_0 = arg0;
2389     let pattern1_0 = arg1;
2390     let pattern2_0 = arg2;
2391     // Rule at src/isa/x64/inst.isle line 1696.
2392     let expr0_0 = MInst::XmmCmpRmR {
2393         op: pattern0_0.clone(),
2394         src: pattern1_0.clone(),
2395         dst: pattern2_0,
2396     };
2397     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2398     return Some(expr1_0);
2399 }
2400 
2401 // Generated as internal constructor for term x64_ucomis.
2402 pub fn constructor_x64_ucomis<C: Context>(
2403     ctx: &mut C,
2404     arg0: Value,
2405     arg1: Value,
2406 ) -> Option<ProducesFlags> {
2407     let pattern0_0 = arg0;
2408     let pattern1_0 = C::value_type(ctx, pattern0_0);
2409     if pattern1_0 == F32 {
2410         let pattern3_0 = arg1;
2411         // Rule at src/isa/x64/inst.isle line 1702.
2412         let expr0_0 = SseOpcode::Ucomiss;
2413         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2414         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2415         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2416         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2417         return Some(expr4_0);
2418     }
2419     if pattern1_0 == F64 {
2420         let pattern3_0 = arg1;
2421         // Rule at src/isa/x64/inst.isle line 1706.
2422         let expr0_0 = SseOpcode::Ucomisd;
2423         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2424         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2425         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2426         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2427         return Some(expr4_0);
2428     }
2429     return None;
2430 }
2431 
2432 // Generated as internal constructor for term x64_test.
2433 pub fn constructor_x64_test<C: Context>(
2434     ctx: &mut C,
2435     arg0: &OperandSize,
2436     arg1: &GprMemImm,
2437     arg2: Gpr,
2438 ) -> Option<ProducesFlags> {
2439     let pattern0_0 = arg0;
2440     let pattern1_0 = arg1;
2441     let pattern2_0 = arg2;
2442     // Rule at src/isa/x64/inst.isle line 1711.
2443     let expr0_0 = CmpOpcode::Test;
2444     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2445     return Some(expr1_0);
2446 }
2447 
2448 // Generated as internal constructor for term cmove.
2449 pub fn constructor_cmove<C: Context>(
2450     ctx: &mut C,
2451     arg0: Type,
2452     arg1: &CC,
2453     arg2: &GprMem,
2454     arg3: Gpr,
2455 ) -> Option<ConsumesFlags> {
2456     let pattern0_0 = arg0;
2457     let pattern1_0 = arg1;
2458     let pattern2_0 = arg2;
2459     let pattern3_0 = arg3;
2460     // Rule at src/isa/x64/inst.isle line 1718.
2461     let expr0_0 = C::temp_writable_gpr(ctx);
2462     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2463     let expr2_0 = MInst::Cmove {
2464         size: expr1_0,
2465         cc: pattern1_0.clone(),
2466         consequent: pattern2_0.clone(),
2467         alternative: pattern3_0,
2468         dst: expr0_0,
2469     };
2470     let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2471     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2472         inst: expr2_0,
2473         result: expr3_0,
2474     };
2475     return Some(expr4_0);
2476 }
2477 
2478 // Generated as internal constructor for term cmove_xmm.
2479 pub fn constructor_cmove_xmm<C: Context>(
2480     ctx: &mut C,
2481     arg0: Type,
2482     arg1: &CC,
2483     arg2: &XmmMem,
2484     arg3: Xmm,
2485 ) -> Option<ConsumesFlags> {
2486     let pattern0_0 = arg0;
2487     let pattern1_0 = arg1;
2488     let pattern2_0 = arg2;
2489     let pattern3_0 = arg3;
2490     // Rule at src/isa/x64/inst.isle line 1726.
2491     let expr0_0 = C::temp_writable_xmm(ctx);
2492     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2493     let expr2_0 = MInst::XmmCmove {
2494         size: expr1_0,
2495         cc: pattern1_0.clone(),
2496         consequent: pattern2_0.clone(),
2497         alternative: pattern3_0,
2498         dst: expr0_0,
2499     };
2500     let expr3_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
2501     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2502         inst: expr2_0,
2503         result: expr3_0,
2504     };
2505     return Some(expr4_0);
2506 }
2507 
2508 // Generated as internal constructor for term cmove_from_values.
2509 pub fn constructor_cmove_from_values<C: Context>(
2510     ctx: &mut C,
2511     arg0: Type,
2512     arg1: &CC,
2513     arg2: Value,
2514     arg3: Value,
2515 ) -> Option<ConsumesFlags> {
2516     let pattern0_0 = arg0;
2517     if pattern0_0 == I128 {
2518         let pattern2_0 = arg1;
2519         let pattern3_0 = arg2;
2520         let pattern4_0 = arg3;
2521         // Rule at src/isa/x64/inst.isle line 1737.
2522         let expr0_0 = C::put_in_regs(ctx, pattern3_0);
2523         let expr1_0 = C::put_in_regs(ctx, pattern4_0);
2524         let expr2_0 = C::temp_writable_gpr(ctx);
2525         let expr3_0 = C::temp_writable_gpr(ctx);
2526         let expr4_0 = OperandSize::Size64;
2527         let expr5_0: usize = 0;
2528         let expr6_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr5_0)?;
2529         let expr7_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
2530         let expr8_0: usize = 0;
2531         let expr9_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr8_0)?;
2532         let expr10_0 = MInst::Cmove {
2533             size: expr4_0,
2534             cc: pattern2_0.clone(),
2535             consequent: expr7_0,
2536             alternative: expr9_0,
2537             dst: expr2_0,
2538         };
2539         let expr11_0: usize = 1;
2540         let expr12_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr11_0)?;
2541         let expr13_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
2542         let expr14_0: usize = 1;
2543         let expr15_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr14_0)?;
2544         let expr16_0 = MInst::Cmove {
2545             size: expr4_0,
2546             cc: pattern2_0.clone(),
2547             consequent: expr13_0,
2548             alternative: expr15_0,
2549             dst: expr3_0,
2550         };
2551         let expr17_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
2552         let expr18_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
2553         let expr19_0 = C::value_regs(ctx, expr17_0, expr18_0);
2554         let expr20_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2555             inst1: expr10_0,
2556             inst2: expr16_0,
2557             result: expr19_0,
2558         };
2559         return Some(expr20_0);
2560     }
2561     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
2562         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2563             let pattern3_0 = arg1;
2564             let pattern4_0 = arg2;
2565             let pattern5_0 = arg3;
2566             // Rule at src/isa/x64/inst.isle line 1761.
2567             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
2568             let expr1_0 = constructor_put_in_xmm(ctx, pattern5_0)?;
2569             let expr2_0 = constructor_cmove_xmm(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2570             return Some(expr2_0);
2571         }
2572     }
2573     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
2574         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2575             let pattern3_0 = arg1;
2576             let pattern4_0 = arg2;
2577             let pattern5_0 = arg3;
2578             // Rule at src/isa/x64/inst.isle line 1758.
2579             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern4_0)?;
2580             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_0)?;
2581             let expr2_0 = constructor_cmove(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2582             return Some(expr2_0);
2583         }
2584     }
2585     return None;
2586 }
2587 
2588 // Generated as internal constructor for term cmove_or.
2589 pub fn constructor_cmove_or<C: Context>(
2590     ctx: &mut C,
2591     arg0: Type,
2592     arg1: &CC,
2593     arg2: &CC,
2594     arg3: &GprMem,
2595     arg4: Gpr,
2596 ) -> Option<ConsumesFlags> {
2597     let pattern0_0 = arg0;
2598     let pattern1_0 = arg1;
2599     let pattern2_0 = arg2;
2600     let pattern3_0 = arg3;
2601     let pattern4_0 = arg4;
2602     // Rule at src/isa/x64/inst.isle line 1768.
2603     let expr0_0 = C::temp_writable_gpr(ctx);
2604     let expr1_0 = C::temp_writable_gpr(ctx);
2605     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2606     let expr3_0 = MInst::Cmove {
2607         size: expr2_0,
2608         cc: pattern1_0.clone(),
2609         consequent: pattern3_0.clone(),
2610         alternative: pattern4_0,
2611         dst: expr1_0,
2612     };
2613     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
2614     let expr5_0 = MInst::Cmove {
2615         size: expr2_0,
2616         cc: pattern2_0.clone(),
2617         consequent: pattern3_0.clone(),
2618         alternative: expr4_0,
2619         dst: expr0_0,
2620     };
2621     let expr6_0 = constructor_writable_gpr_to_value_regs(ctx, expr0_0)?;
2622     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2623         inst1: expr3_0,
2624         inst2: expr5_0,
2625         result: expr6_0,
2626     };
2627     return Some(expr7_0);
2628 }
2629 
2630 // Generated as internal constructor for term cmove_or_xmm.
2631 pub fn constructor_cmove_or_xmm<C: Context>(
2632     ctx: &mut C,
2633     arg0: Type,
2634     arg1: &CC,
2635     arg2: &CC,
2636     arg3: &XmmMem,
2637     arg4: Xmm,
2638 ) -> Option<ConsumesFlags> {
2639     let pattern0_0 = arg0;
2640     let pattern1_0 = arg1;
2641     let pattern2_0 = arg2;
2642     let pattern3_0 = arg3;
2643     let pattern4_0 = arg4;
2644     // Rule at src/isa/x64/inst.isle line 1780.
2645     let expr0_0 = C::temp_writable_xmm(ctx);
2646     let expr1_0 = C::temp_writable_xmm(ctx);
2647     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2648     let expr3_0 = MInst::XmmCmove {
2649         size: expr2_0,
2650         cc: pattern1_0.clone(),
2651         consequent: pattern3_0.clone(),
2652         alternative: pattern4_0,
2653         dst: expr1_0,
2654     };
2655     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr1_0);
2656     let expr5_0 = MInst::XmmCmove {
2657         size: expr2_0,
2658         cc: pattern2_0.clone(),
2659         consequent: pattern3_0.clone(),
2660         alternative: expr4_0,
2661         dst: expr0_0,
2662     };
2663     let expr6_0 = constructor_writable_xmm_to_value_regs(ctx, expr0_0)?;
2664     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2665         inst1: expr3_0,
2666         inst2: expr5_0,
2667         result: expr6_0,
2668     };
2669     return Some(expr7_0);
2670 }
2671 
2672 // Generated as internal constructor for term cmove_or_from_values.
2673 pub fn constructor_cmove_or_from_values<C: Context>(
2674     ctx: &mut C,
2675     arg0: Type,
2676     arg1: &CC,
2677     arg2: &CC,
2678     arg3: Value,
2679     arg4: Value,
2680 ) -> Option<ConsumesFlags> {
2681     let pattern0_0 = arg0;
2682     if pattern0_0 == I128 {
2683         let pattern2_0 = arg1;
2684         let pattern3_0 = arg2;
2685         let pattern4_0 = arg3;
2686         let pattern5_0 = arg4;
2687         // Rule at src/isa/x64/inst.isle line 1795.
2688         let expr0_0 = C::put_in_regs(ctx, pattern4_0);
2689         let expr1_0 = C::put_in_regs(ctx, pattern5_0);
2690         let expr2_0 = C::temp_writable_gpr(ctx);
2691         let expr3_0 = C::temp_writable_gpr(ctx);
2692         let expr4_0 = C::temp_writable_gpr(ctx);
2693         let expr5_0 = C::temp_writable_gpr(ctx);
2694         let expr6_0 = OperandSize::Size64;
2695         let expr7_0: usize = 0;
2696         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr7_0)?;
2697         let expr9_0 = C::gpr_to_gpr_mem(ctx, expr8_0);
2698         let expr10_0: usize = 0;
2699         let expr11_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr10_0)?;
2700         let expr12_0 = MInst::Cmove {
2701             size: expr6_0,
2702             cc: pattern2_0.clone(),
2703             consequent: expr9_0,
2704             alternative: expr11_0,
2705             dst: expr4_0,
2706         };
2707         let expr13_0: usize = 0;
2708         let expr14_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr13_0)?;
2709         let expr15_0 = C::gpr_to_gpr_mem(ctx, expr14_0);
2710         let expr16_0 = C::writable_gpr_to_gpr(ctx, expr4_0);
2711         let expr17_0 = MInst::Cmove {
2712             size: expr6_0,
2713             cc: pattern3_0.clone(),
2714             consequent: expr15_0,
2715             alternative: expr16_0,
2716             dst: expr2_0,
2717         };
2718         let expr18_0: usize = 1;
2719         let expr19_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr18_0)?;
2720         let expr20_0 = C::gpr_to_gpr_mem(ctx, expr19_0);
2721         let expr21_0: usize = 1;
2722         let expr22_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr21_0)?;
2723         let expr23_0 = MInst::Cmove {
2724             size: expr6_0,
2725             cc: pattern2_0.clone(),
2726             consequent: expr20_0,
2727             alternative: expr22_0,
2728             dst: expr5_0,
2729         };
2730         let expr24_0: usize = 1;
2731         let expr25_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr24_0)?;
2732         let expr26_0 = C::gpr_to_gpr_mem(ctx, expr25_0);
2733         let expr27_0 = C::writable_gpr_to_gpr(ctx, expr5_0);
2734         let expr28_0 = MInst::Cmove {
2735             size: expr6_0,
2736             cc: pattern3_0.clone(),
2737             consequent: expr26_0,
2738             alternative: expr27_0,
2739             dst: expr3_0,
2740         };
2741         let expr29_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
2742         let expr30_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
2743         let expr31_0 = C::value_regs(ctx, expr29_0, expr30_0);
2744         let expr32_0 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
2745             inst1: expr12_0,
2746             inst2: expr17_0,
2747             inst3: expr23_0,
2748             inst4: expr28_0,
2749             result: expr31_0,
2750         };
2751         return Some(expr32_0);
2752     }
2753     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
2754         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2755             let pattern3_0 = arg1;
2756             let pattern4_0 = arg2;
2757             let pattern5_0 = arg3;
2758             let pattern6_0 = arg4;
2759             // Rule at src/isa/x64/inst.isle line 1817.
2760             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_0)?;
2761             let expr1_0 = constructor_put_in_xmm(ctx, pattern6_0)?;
2762             let expr2_0 = constructor_cmove_or_xmm(
2763                 ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0,
2764             )?;
2765             return Some(expr2_0);
2766         }
2767     }
2768     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
2769         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2770             let pattern3_0 = arg1;
2771             let pattern4_0 = arg2;
2772             let pattern5_0 = arg3;
2773             let pattern6_0 = arg4;
2774             // Rule at src/isa/x64/inst.isle line 1814.
2775             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern5_0)?;
2776             let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
2777             let expr2_0 =
2778                 constructor_cmove_or(ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0)?;
2779             return Some(expr2_0);
2780         }
2781     }
2782     return None;
2783 }
2784 
2785 // Generated as internal constructor for term x64_setcc.
2786 pub fn constructor_x64_setcc<C: Context>(ctx: &mut C, arg0: &CC) -> Option<ConsumesFlags> {
2787     let pattern0_0 = arg0;
2788     // Rule at src/isa/x64/inst.isle line 1822.
2789     let expr0_0 = C::temp_writable_gpr(ctx);
2790     let expr1_0 = MInst::Setcc {
2791         cc: pattern0_0.clone(),
2792         dst: expr0_0,
2793     };
2794     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2795     let expr3_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2796         inst: expr1_0,
2797         result: expr2_0,
2798     };
2799     return Some(expr3_0);
2800 }
2801 
2802 // Generated as internal constructor for term xmm_rm_r.
2803 pub fn constructor_xmm_rm_r<C: Context>(
2804     ctx: &mut C,
2805     arg0: Type,
2806     arg1: &SseOpcode,
2807     arg2: Xmm,
2808     arg3: &XmmMem,
2809 ) -> Option<Xmm> {
2810     let pattern0_0 = arg0;
2811     let pattern1_0 = arg1;
2812     let pattern2_0 = arg2;
2813     let pattern3_0 = arg3;
2814     // Rule at src/isa/x64/inst.isle line 1830.
2815     let expr0_0 = C::temp_writable_xmm(ctx);
2816     let expr1_0 = MInst::XmmRmR {
2817         op: pattern1_0.clone(),
2818         src1: pattern2_0,
2819         src2: pattern3_0.clone(),
2820         dst: expr0_0,
2821     };
2822     let expr2_0 = C::emit(ctx, &expr1_0);
2823     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2824     return Some(expr3_0);
2825 }
2826 
2827 // Generated as internal constructor for term x64_paddb.
2828 pub fn constructor_x64_paddb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2829     let pattern0_0 = arg0;
2830     let pattern1_0 = arg1;
2831     // Rule at src/isa/x64/inst.isle line 1837.
2832     let expr0_0: Type = I8X16;
2833     let expr1_0 = SseOpcode::Paddb;
2834     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2835     return Some(expr2_0);
2836 }
2837 
2838 // Generated as internal constructor for term x64_paddw.
2839 pub fn constructor_x64_paddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2840     let pattern0_0 = arg0;
2841     let pattern1_0 = arg1;
2842     // Rule at src/isa/x64/inst.isle line 1842.
2843     let expr0_0: Type = I16X8;
2844     let expr1_0 = SseOpcode::Paddw;
2845     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2846     return Some(expr2_0);
2847 }
2848 
2849 // Generated as internal constructor for term x64_paddd.
2850 pub fn constructor_x64_paddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2851     let pattern0_0 = arg0;
2852     let pattern1_0 = arg1;
2853     // Rule at src/isa/x64/inst.isle line 1847.
2854     let expr0_0: Type = I32X4;
2855     let expr1_0 = SseOpcode::Paddd;
2856     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2857     return Some(expr2_0);
2858 }
2859 
2860 // Generated as internal constructor for term x64_paddq.
2861 pub fn constructor_x64_paddq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2862     let pattern0_0 = arg0;
2863     let pattern1_0 = arg1;
2864     // Rule at src/isa/x64/inst.isle line 1852.
2865     let expr0_0: Type = I64X2;
2866     let expr1_0 = SseOpcode::Paddq;
2867     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2868     return Some(expr2_0);
2869 }
2870 
2871 // Generated as internal constructor for term x64_paddsb.
2872 pub fn constructor_x64_paddsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2873     let pattern0_0 = arg0;
2874     let pattern1_0 = arg1;
2875     // Rule at src/isa/x64/inst.isle line 1857.
2876     let expr0_0: Type = I8X16;
2877     let expr1_0 = SseOpcode::Paddsb;
2878     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2879     return Some(expr2_0);
2880 }
2881 
2882 // Generated as internal constructor for term x64_paddsw.
2883 pub fn constructor_x64_paddsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2884     let pattern0_0 = arg0;
2885     let pattern1_0 = arg1;
2886     // Rule at src/isa/x64/inst.isle line 1862.
2887     let expr0_0: Type = I16X8;
2888     let expr1_0 = SseOpcode::Paddsw;
2889     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2890     return Some(expr2_0);
2891 }
2892 
2893 // Generated as internal constructor for term x64_paddusb.
2894 pub fn constructor_x64_paddusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2895     let pattern0_0 = arg0;
2896     let pattern1_0 = arg1;
2897     // Rule at src/isa/x64/inst.isle line 1867.
2898     let expr0_0: Type = I8X16;
2899     let expr1_0 = SseOpcode::Paddusb;
2900     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2901     return Some(expr2_0);
2902 }
2903 
2904 // Generated as internal constructor for term x64_paddusw.
2905 pub fn constructor_x64_paddusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2906     let pattern0_0 = arg0;
2907     let pattern1_0 = arg1;
2908     // Rule at src/isa/x64/inst.isle line 1872.
2909     let expr0_0: Type = I16X8;
2910     let expr1_0 = SseOpcode::Paddusw;
2911     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2912     return Some(expr2_0);
2913 }
2914 
2915 // Generated as internal constructor for term x64_psubb.
2916 pub fn constructor_x64_psubb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2917     let pattern0_0 = arg0;
2918     let pattern1_0 = arg1;
2919     // Rule at src/isa/x64/inst.isle line 1877.
2920     let expr0_0: Type = I8X16;
2921     let expr1_0 = SseOpcode::Psubb;
2922     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2923     return Some(expr2_0);
2924 }
2925 
2926 // Generated as internal constructor for term x64_psubw.
2927 pub fn constructor_x64_psubw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2928     let pattern0_0 = arg0;
2929     let pattern1_0 = arg1;
2930     // Rule at src/isa/x64/inst.isle line 1882.
2931     let expr0_0: Type = I16X8;
2932     let expr1_0 = SseOpcode::Psubw;
2933     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2934     return Some(expr2_0);
2935 }
2936 
2937 // Generated as internal constructor for term x64_psubd.
2938 pub fn constructor_x64_psubd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2939     let pattern0_0 = arg0;
2940     let pattern1_0 = arg1;
2941     // Rule at src/isa/x64/inst.isle line 1887.
2942     let expr0_0: Type = I32X4;
2943     let expr1_0 = SseOpcode::Psubd;
2944     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2945     return Some(expr2_0);
2946 }
2947 
2948 // Generated as internal constructor for term x64_psubq.
2949 pub fn constructor_x64_psubq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2950     let pattern0_0 = arg0;
2951     let pattern1_0 = arg1;
2952     // Rule at src/isa/x64/inst.isle line 1892.
2953     let expr0_0: Type = I64X2;
2954     let expr1_0 = SseOpcode::Psubq;
2955     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2956     return Some(expr2_0);
2957 }
2958 
2959 // Generated as internal constructor for term x64_psubsb.
2960 pub fn constructor_x64_psubsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2961     let pattern0_0 = arg0;
2962     let pattern1_0 = arg1;
2963     // Rule at src/isa/x64/inst.isle line 1897.
2964     let expr0_0: Type = I8X16;
2965     let expr1_0 = SseOpcode::Psubsb;
2966     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2967     return Some(expr2_0);
2968 }
2969 
2970 // Generated as internal constructor for term x64_psubsw.
2971 pub fn constructor_x64_psubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2972     let pattern0_0 = arg0;
2973     let pattern1_0 = arg1;
2974     // Rule at src/isa/x64/inst.isle line 1902.
2975     let expr0_0: Type = I16X8;
2976     let expr1_0 = SseOpcode::Psubsw;
2977     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2978     return Some(expr2_0);
2979 }
2980 
2981 // Generated as internal constructor for term x64_psubusb.
2982 pub fn constructor_x64_psubusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2983     let pattern0_0 = arg0;
2984     let pattern1_0 = arg1;
2985     // Rule at src/isa/x64/inst.isle line 1907.
2986     let expr0_0: Type = I8X16;
2987     let expr1_0 = SseOpcode::Psubusb;
2988     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2989     return Some(expr2_0);
2990 }
2991 
2992 // Generated as internal constructor for term x64_psubusw.
2993 pub fn constructor_x64_psubusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2994     let pattern0_0 = arg0;
2995     let pattern1_0 = arg1;
2996     // Rule at src/isa/x64/inst.isle line 1912.
2997     let expr0_0: Type = I16X8;
2998     let expr1_0 = SseOpcode::Psubusw;
2999     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3000     return Some(expr2_0);
3001 }
3002 
3003 // Generated as internal constructor for term x64_pavgb.
3004 pub fn constructor_x64_pavgb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3005     let pattern0_0 = arg0;
3006     let pattern1_0 = arg1;
3007     // Rule at src/isa/x64/inst.isle line 1917.
3008     let expr0_0: Type = I8X16;
3009     let expr1_0 = SseOpcode::Pavgb;
3010     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3011     return Some(expr2_0);
3012 }
3013 
3014 // Generated as internal constructor for term x64_pavgw.
3015 pub fn constructor_x64_pavgw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3016     let pattern0_0 = arg0;
3017     let pattern1_0 = arg1;
3018     // Rule at src/isa/x64/inst.isle line 1922.
3019     let expr0_0: Type = I16X8;
3020     let expr1_0 = SseOpcode::Pavgw;
3021     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3022     return Some(expr2_0);
3023 }
3024 
3025 // Generated as internal constructor for term x64_pand.
3026 pub fn constructor_x64_pand<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3027     let pattern0_0 = arg0;
3028     let pattern1_0 = arg1;
3029     // Rule at src/isa/x64/inst.isle line 1927.
3030     let expr0_0: Type = F32X4;
3031     let expr1_0 = SseOpcode::Pand;
3032     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3033     return Some(expr2_0);
3034 }
3035 
3036 // Generated as internal constructor for term x64_andps.
3037 pub fn constructor_x64_andps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3038     let pattern0_0 = arg0;
3039     let pattern1_0 = arg1;
3040     // Rule at src/isa/x64/inst.isle line 1932.
3041     let expr0_0: Type = F32X4;
3042     let expr1_0 = SseOpcode::Andps;
3043     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3044     return Some(expr2_0);
3045 }
3046 
3047 // Generated as internal constructor for term x64_andpd.
3048 pub fn constructor_x64_andpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3049     let pattern0_0 = arg0;
3050     let pattern1_0 = arg1;
3051     // Rule at src/isa/x64/inst.isle line 1937.
3052     let expr0_0: Type = F64X2;
3053     let expr1_0 = SseOpcode::Andpd;
3054     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3055     return Some(expr2_0);
3056 }
3057 
3058 // Generated as internal constructor for term x64_por.
3059 pub fn constructor_x64_por<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3060     let pattern0_0 = arg0;
3061     let pattern1_0 = arg1;
3062     // Rule at src/isa/x64/inst.isle line 1942.
3063     let expr0_0: Type = F32X4;
3064     let expr1_0 = SseOpcode::Por;
3065     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3066     return Some(expr2_0);
3067 }
3068 
3069 // Generated as internal constructor for term x64_orps.
3070 pub fn constructor_x64_orps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3071     let pattern0_0 = arg0;
3072     let pattern1_0 = arg1;
3073     // Rule at src/isa/x64/inst.isle line 1947.
3074     let expr0_0: Type = F32X4;
3075     let expr1_0 = SseOpcode::Orps;
3076     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3077     return Some(expr2_0);
3078 }
3079 
3080 // Generated as internal constructor for term x64_orpd.
3081 pub fn constructor_x64_orpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3082     let pattern0_0 = arg0;
3083     let pattern1_0 = arg1;
3084     // Rule at src/isa/x64/inst.isle line 1952.
3085     let expr0_0: Type = F64X2;
3086     let expr1_0 = SseOpcode::Orpd;
3087     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3088     return Some(expr2_0);
3089 }
3090 
3091 // Generated as internal constructor for term x64_pxor.
3092 pub fn constructor_x64_pxor<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3093     let pattern0_0 = arg0;
3094     let pattern1_0 = arg1;
3095     // Rule at src/isa/x64/inst.isle line 1957.
3096     let expr0_0: Type = I8X16;
3097     let expr1_0 = SseOpcode::Pxor;
3098     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3099     return Some(expr2_0);
3100 }
3101 
3102 // Generated as internal constructor for term x64_xorps.
3103 pub fn constructor_x64_xorps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3104     let pattern0_0 = arg0;
3105     let pattern1_0 = arg1;
3106     // Rule at src/isa/x64/inst.isle line 1962.
3107     let expr0_0: Type = F32X4;
3108     let expr1_0 = SseOpcode::Xorps;
3109     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3110     return Some(expr2_0);
3111 }
3112 
3113 // Generated as internal constructor for term x64_xorpd.
3114 pub fn constructor_x64_xorpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3115     let pattern0_0 = arg0;
3116     let pattern1_0 = arg1;
3117     // Rule at src/isa/x64/inst.isle line 1967.
3118     let expr0_0: Type = F64X2;
3119     let expr1_0 = SseOpcode::Xorpd;
3120     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3121     return Some(expr2_0);
3122 }
3123 
3124 // Generated as internal constructor for term x64_pmullw.
3125 pub fn constructor_x64_pmullw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3126     let pattern0_0 = arg0;
3127     let pattern1_0 = arg1;
3128     // Rule at src/isa/x64/inst.isle line 1972.
3129     let expr0_0: Type = I16X8;
3130     let expr1_0 = SseOpcode::Pmullw;
3131     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3132     return Some(expr2_0);
3133 }
3134 
3135 // Generated as internal constructor for term x64_pmulld.
3136 pub fn constructor_x64_pmulld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3137     let pattern0_0 = arg0;
3138     let pattern1_0 = arg1;
3139     // Rule at src/isa/x64/inst.isle line 1977.
3140     let expr0_0: Type = I16X8;
3141     let expr1_0 = SseOpcode::Pmulld;
3142     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3143     return Some(expr2_0);
3144 }
3145 
3146 // Generated as internal constructor for term x64_pmulhw.
3147 pub fn constructor_x64_pmulhw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3148     let pattern0_0 = arg0;
3149     let pattern1_0 = arg1;
3150     // Rule at src/isa/x64/inst.isle line 1982.
3151     let expr0_0: Type = I16X8;
3152     let expr1_0 = SseOpcode::Pmulhw;
3153     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3154     return Some(expr2_0);
3155 }
3156 
3157 // Generated as internal constructor for term x64_pmulhuw.
3158 pub fn constructor_x64_pmulhuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3159     let pattern0_0 = arg0;
3160     let pattern1_0 = arg1;
3161     // Rule at src/isa/x64/inst.isle line 1987.
3162     let expr0_0: Type = I16X8;
3163     let expr1_0 = SseOpcode::Pmulhuw;
3164     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3165     return Some(expr2_0);
3166 }
3167 
3168 // Generated as internal constructor for term x64_pmuldq.
3169 pub fn constructor_x64_pmuldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3170     let pattern0_0 = arg0;
3171     let pattern1_0 = arg1;
3172     // Rule at src/isa/x64/inst.isle line 1992.
3173     let expr0_0: Type = I16X8;
3174     let expr1_0 = SseOpcode::Pmuldq;
3175     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3176     return Some(expr2_0);
3177 }
3178 
3179 // Generated as internal constructor for term x64_pmuludq.
3180 pub fn constructor_x64_pmuludq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3181     let pattern0_0 = arg0;
3182     let pattern1_0 = arg1;
3183     // Rule at src/isa/x64/inst.isle line 1997.
3184     let expr0_0: Type = I64X2;
3185     let expr1_0 = SseOpcode::Pmuludq;
3186     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3187     return Some(expr2_0);
3188 }
3189 
3190 // Generated as internal constructor for term x64_punpckhwd.
3191 pub fn constructor_x64_punpckhwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3192     let pattern0_0 = arg0;
3193     let pattern1_0 = arg1;
3194     // Rule at src/isa/x64/inst.isle line 2002.
3195     let expr0_0: Type = I16X8;
3196     let expr1_0 = SseOpcode::Punpckhwd;
3197     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3198     return Some(expr2_0);
3199 }
3200 
3201 // Generated as internal constructor for term x64_punpcklwd.
3202 pub fn constructor_x64_punpcklwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3203     let pattern0_0 = arg0;
3204     let pattern1_0 = arg1;
3205     // Rule at src/isa/x64/inst.isle line 2007.
3206     let expr0_0: Type = I16X8;
3207     let expr1_0 = SseOpcode::Punpcklwd;
3208     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3209     return Some(expr2_0);
3210 }
3211 
3212 // Generated as internal constructor for term x64_andnps.
3213 pub fn constructor_x64_andnps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3214     let pattern0_0 = arg0;
3215     let pattern1_0 = arg1;
3216     // Rule at src/isa/x64/inst.isle line 2012.
3217     let expr0_0: Type = F32X4;
3218     let expr1_0 = SseOpcode::Andnps;
3219     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3220     return Some(expr2_0);
3221 }
3222 
3223 // Generated as internal constructor for term x64_andnpd.
3224 pub fn constructor_x64_andnpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3225     let pattern0_0 = arg0;
3226     let pattern1_0 = arg1;
3227     // Rule at src/isa/x64/inst.isle line 2017.
3228     let expr0_0: Type = F64X2;
3229     let expr1_0 = SseOpcode::Andnpd;
3230     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3231     return Some(expr2_0);
3232 }
3233 
3234 // Generated as internal constructor for term x64_pandn.
3235 pub fn constructor_x64_pandn<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3236     let pattern0_0 = arg0;
3237     let pattern1_0 = arg1;
3238     // Rule at src/isa/x64/inst.isle line 2022.
3239     let expr0_0: Type = F64X2;
3240     let expr1_0 = SseOpcode::Pandn;
3241     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3242     return Some(expr2_0);
3243 }
3244 
3245 // Generated as internal constructor for term x64_addss.
3246 pub fn constructor_x64_addss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3247     let pattern0_0 = arg0;
3248     let pattern1_0 = arg1;
3249     // Rule at src/isa/x64/inst.isle line 2027.
3250     let expr0_0: Type = F32;
3251     let expr1_0 = SseOpcode::Addss;
3252     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3253     return Some(expr2_0);
3254 }
3255 
3256 // Generated as internal constructor for term x64_addsd.
3257 pub fn constructor_x64_addsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3258     let pattern0_0 = arg0;
3259     let pattern1_0 = arg1;
3260     // Rule at src/isa/x64/inst.isle line 2032.
3261     let expr0_0: Type = F64;
3262     let expr1_0 = SseOpcode::Addsd;
3263     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3264     return Some(expr2_0);
3265 }
3266 
3267 // Generated as internal constructor for term x64_addps.
3268 pub fn constructor_x64_addps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3269     let pattern0_0 = arg0;
3270     let pattern1_0 = arg1;
3271     // Rule at src/isa/x64/inst.isle line 2037.
3272     let expr0_0: Type = F32;
3273     let expr1_0 = SseOpcode::Addps;
3274     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3275     return Some(expr2_0);
3276 }
3277 
3278 // Generated as internal constructor for term x64_addpd.
3279 pub fn constructor_x64_addpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3280     let pattern0_0 = arg0;
3281     let pattern1_0 = arg1;
3282     // Rule at src/isa/x64/inst.isle line 2042.
3283     let expr0_0: Type = F32;
3284     let expr1_0 = SseOpcode::Addpd;
3285     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3286     return Some(expr2_0);
3287 }
3288 
3289 // Generated as internal constructor for term x64_subss.
3290 pub fn constructor_x64_subss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3291     let pattern0_0 = arg0;
3292     let pattern1_0 = arg1;
3293     // Rule at src/isa/x64/inst.isle line 2047.
3294     let expr0_0: Type = F32;
3295     let expr1_0 = SseOpcode::Subss;
3296     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3297     return Some(expr2_0);
3298 }
3299 
3300 // Generated as internal constructor for term x64_subsd.
3301 pub fn constructor_x64_subsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3302     let pattern0_0 = arg0;
3303     let pattern1_0 = arg1;
3304     // Rule at src/isa/x64/inst.isle line 2052.
3305     let expr0_0: Type = F64;
3306     let expr1_0 = SseOpcode::Subsd;
3307     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3308     return Some(expr2_0);
3309 }
3310 
3311 // Generated as internal constructor for term x64_subps.
3312 pub fn constructor_x64_subps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3313     let pattern0_0 = arg0;
3314     let pattern1_0 = arg1;
3315     // Rule at src/isa/x64/inst.isle line 2057.
3316     let expr0_0: Type = F32;
3317     let expr1_0 = SseOpcode::Subps;
3318     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3319     return Some(expr2_0);
3320 }
3321 
3322 // Generated as internal constructor for term x64_subpd.
3323 pub fn constructor_x64_subpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3324     let pattern0_0 = arg0;
3325     let pattern1_0 = arg1;
3326     // Rule at src/isa/x64/inst.isle line 2062.
3327     let expr0_0: Type = F32;
3328     let expr1_0 = SseOpcode::Subpd;
3329     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3330     return Some(expr2_0);
3331 }
3332 
3333 // Generated as internal constructor for term x64_mulss.
3334 pub fn constructor_x64_mulss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3335     let pattern0_0 = arg0;
3336     let pattern1_0 = arg1;
3337     // Rule at src/isa/x64/inst.isle line 2067.
3338     let expr0_0: Type = F32;
3339     let expr1_0 = SseOpcode::Mulss;
3340     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3341     return Some(expr2_0);
3342 }
3343 
3344 // Generated as internal constructor for term x64_mulsd.
3345 pub fn constructor_x64_mulsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3346     let pattern0_0 = arg0;
3347     let pattern1_0 = arg1;
3348     // Rule at src/isa/x64/inst.isle line 2072.
3349     let expr0_0: Type = F64;
3350     let expr1_0 = SseOpcode::Mulsd;
3351     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3352     return Some(expr2_0);
3353 }
3354 
3355 // Generated as internal constructor for term x64_mulps.
3356 pub fn constructor_x64_mulps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3357     let pattern0_0 = arg0;
3358     let pattern1_0 = arg1;
3359     // Rule at src/isa/x64/inst.isle line 2077.
3360     let expr0_0: Type = F32;
3361     let expr1_0 = SseOpcode::Mulps;
3362     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3363     return Some(expr2_0);
3364 }
3365 
3366 // Generated as internal constructor for term x64_mulpd.
3367 pub fn constructor_x64_mulpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3368     let pattern0_0 = arg0;
3369     let pattern1_0 = arg1;
3370     // Rule at src/isa/x64/inst.isle line 2082.
3371     let expr0_0: Type = F32;
3372     let expr1_0 = SseOpcode::Mulpd;
3373     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3374     return Some(expr2_0);
3375 }
3376 
3377 // Generated as internal constructor for term x64_divss.
3378 pub fn constructor_x64_divss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3379     let pattern0_0 = arg0;
3380     let pattern1_0 = arg1;
3381     // Rule at src/isa/x64/inst.isle line 2087.
3382     let expr0_0: Type = F32;
3383     let expr1_0 = SseOpcode::Divss;
3384     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3385     return Some(expr2_0);
3386 }
3387 
3388 // Generated as internal constructor for term x64_divsd.
3389 pub fn constructor_x64_divsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3390     let pattern0_0 = arg0;
3391     let pattern1_0 = arg1;
3392     // Rule at src/isa/x64/inst.isle line 2092.
3393     let expr0_0: Type = F64;
3394     let expr1_0 = SseOpcode::Divsd;
3395     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3396     return Some(expr2_0);
3397 }
3398 
3399 // Generated as internal constructor for term x64_divps.
3400 pub fn constructor_x64_divps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3401     let pattern0_0 = arg0;
3402     let pattern1_0 = arg1;
3403     // Rule at src/isa/x64/inst.isle line 2097.
3404     let expr0_0: Type = F32;
3405     let expr1_0 = SseOpcode::Divps;
3406     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3407     return Some(expr2_0);
3408 }
3409 
3410 // Generated as internal constructor for term x64_divpd.
3411 pub fn constructor_x64_divpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3412     let pattern0_0 = arg0;
3413     let pattern1_0 = arg1;
3414     // Rule at src/isa/x64/inst.isle line 2102.
3415     let expr0_0: Type = F32;
3416     let expr1_0 = SseOpcode::Divpd;
3417     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3418     return Some(expr2_0);
3419 }
3420 
3421 // Generated as internal constructor for term sse_blend_op.
3422 pub fn constructor_sse_blend_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3423     let pattern0_0 = arg0;
3424     if pattern0_0 == F32X4 {
3425         // Rule at src/isa/x64/inst.isle line 2106.
3426         let expr0_0 = SseOpcode::Blendvps;
3427         return Some(expr0_0);
3428     }
3429     if pattern0_0 == F64X2 {
3430         // Rule at src/isa/x64/inst.isle line 2107.
3431         let expr0_0 = SseOpcode::Blendvpd;
3432         return Some(expr0_0);
3433     }
3434     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3435         // Rule at src/isa/x64/inst.isle line 2108.
3436         let expr0_0 = SseOpcode::Pblendvb;
3437         return Some(expr0_0);
3438     }
3439     return None;
3440 }
3441 
3442 // Generated as internal constructor for term sse_mov_op.
3443 pub fn constructor_sse_mov_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3444     let pattern0_0 = arg0;
3445     if pattern0_0 == F32X4 {
3446         // Rule at src/isa/x64/inst.isle line 2111.
3447         let expr0_0 = SseOpcode::Movaps;
3448         return Some(expr0_0);
3449     }
3450     if pattern0_0 == F64X2 {
3451         // Rule at src/isa/x64/inst.isle line 2112.
3452         let expr0_0 = SseOpcode::Movapd;
3453         return Some(expr0_0);
3454     }
3455     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3456         // Rule at src/isa/x64/inst.isle line 2113.
3457         let expr0_0 = SseOpcode::Movdqa;
3458         return Some(expr0_0);
3459     }
3460     return None;
3461 }
3462 
3463 // Generated as internal constructor for term x64_blend.
3464 pub fn constructor_x64_blend<C: Context>(
3465     ctx: &mut C,
3466     arg0: Type,
3467     arg1: &XmmMem,
3468     arg2: &XmmMem,
3469     arg3: Xmm,
3470 ) -> Option<Xmm> {
3471     let pattern0_0 = arg0;
3472     let pattern1_0 = arg1;
3473     let pattern2_0 = arg2;
3474     let pattern3_0 = arg3;
3475     // Rule at src/isa/x64/inst.isle line 2117.
3476     let expr0_0 = C::xmm0(ctx);
3477     let expr1_0 = constructor_sse_mov_op(ctx, pattern0_0)?;
3478     let expr2_0 = MInst::XmmUnaryRmR {
3479         op: expr1_0,
3480         src: pattern1_0.clone(),
3481         dst: expr0_0,
3482     };
3483     let expr3_0 = C::emit(ctx, &expr2_0);
3484     let expr4_0 = constructor_sse_blend_op(ctx, pattern0_0)?;
3485     let expr5_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr4_0, pattern3_0, pattern2_0)?;
3486     return Some(expr5_0);
3487 }
3488 
3489 // Generated as internal constructor for term x64_blendvpd.
3490 pub fn constructor_x64_blendvpd<C: Context>(
3491     ctx: &mut C,
3492     arg0: Xmm,
3493     arg1: &XmmMem,
3494     arg2: Xmm,
3495 ) -> Option<Xmm> {
3496     let pattern0_0 = arg0;
3497     let pattern1_0 = arg1;
3498     let pattern2_0 = arg2;
3499     // Rule at src/isa/x64/inst.isle line 2131.
3500     let expr0_0 = C::xmm0(ctx);
3501     let expr1_0 = SseOpcode::Movapd;
3502     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern2_0);
3503     let expr3_0 = MInst::XmmUnaryRmR {
3504         op: expr1_0,
3505         src: expr2_0,
3506         dst: expr0_0,
3507     };
3508     let expr4_0 = C::emit(ctx, &expr3_0);
3509     let expr5_0: Type = F64X2;
3510     let expr6_0 = SseOpcode::Blendvpd;
3511     let expr7_0 = constructor_xmm_rm_r(ctx, expr5_0, &expr6_0, pattern0_0, pattern1_0)?;
3512     return Some(expr7_0);
3513 }
3514 
3515 // Generated as internal constructor for term x64_movsd_regmove.
3516 pub fn constructor_x64_movsd_regmove<C: Context>(
3517     ctx: &mut C,
3518     arg0: Xmm,
3519     arg1: &XmmMem,
3520 ) -> Option<Xmm> {
3521     let pattern0_0 = arg0;
3522     let pattern1_0 = arg1;
3523     // Rule at src/isa/x64/inst.isle line 2145.
3524     let expr0_0: Type = I8X16;
3525     let expr1_0 = SseOpcode::Movsd;
3526     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3527     return Some(expr2_0);
3528 }
3529 
3530 // Generated as internal constructor for term x64_movlhps.
3531 pub fn constructor_x64_movlhps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3532     let pattern0_0 = arg0;
3533     let pattern1_0 = arg1;
3534     // Rule at src/isa/x64/inst.isle line 2150.
3535     let expr0_0: Type = I8X16;
3536     let expr1_0 = SseOpcode::Movlhps;
3537     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3538     return Some(expr2_0);
3539 }
3540 
3541 // Generated as internal constructor for term x64_pmaxs.
3542 pub fn constructor_x64_pmaxs<C: Context>(
3543     ctx: &mut C,
3544     arg0: Type,
3545     arg1: Xmm,
3546     arg2: &XmmMem,
3547 ) -> Option<Xmm> {
3548     let pattern0_0 = arg0;
3549     if pattern0_0 == I8X16 {
3550         let pattern2_0 = arg1;
3551         let pattern3_0 = arg2;
3552         // Rule at src/isa/x64/inst.isle line 2155.
3553         let expr0_0 = constructor_x64_pmaxsb(ctx, pattern2_0, pattern3_0)?;
3554         return Some(expr0_0);
3555     }
3556     if pattern0_0 == I16X8 {
3557         let pattern2_0 = arg1;
3558         let pattern3_0 = arg2;
3559         // Rule at src/isa/x64/inst.isle line 2156.
3560         let expr0_0 = constructor_x64_pmaxsw(ctx, pattern2_0, pattern3_0)?;
3561         return Some(expr0_0);
3562     }
3563     if pattern0_0 == I32X4 {
3564         let pattern2_0 = arg1;
3565         let pattern3_0 = arg2;
3566         // Rule at src/isa/x64/inst.isle line 2157.
3567         let expr0_0 = constructor_x64_pmaxsd(ctx, pattern2_0, pattern3_0)?;
3568         return Some(expr0_0);
3569     }
3570     return None;
3571 }
3572 
3573 // Generated as internal constructor for term x64_pmaxsb.
3574 pub fn constructor_x64_pmaxsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3575     let pattern0_0 = arg0;
3576     let pattern1_0 = arg1;
3577     // Rule at src/isa/x64/inst.isle line 2160.
3578     let expr0_0: Type = I8X16;
3579     let expr1_0 = SseOpcode::Pmaxsb;
3580     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3581     return Some(expr2_0);
3582 }
3583 
3584 // Generated as internal constructor for term x64_pmaxsw.
3585 pub fn constructor_x64_pmaxsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3586     let pattern0_0 = arg0;
3587     let pattern1_0 = arg1;
3588     // Rule at src/isa/x64/inst.isle line 2162.
3589     let expr0_0: Type = I8X16;
3590     let expr1_0 = SseOpcode::Pmaxsw;
3591     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3592     return Some(expr2_0);
3593 }
3594 
3595 // Generated as internal constructor for term x64_pmaxsd.
3596 pub fn constructor_x64_pmaxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3597     let pattern0_0 = arg0;
3598     let pattern1_0 = arg1;
3599     // Rule at src/isa/x64/inst.isle line 2164.
3600     let expr0_0: Type = I8X16;
3601     let expr1_0 = SseOpcode::Pmaxsd;
3602     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3603     return Some(expr2_0);
3604 }
3605 
3606 // Generated as internal constructor for term x64_pmins.
3607 pub fn constructor_x64_pmins<C: Context>(
3608     ctx: &mut C,
3609     arg0: Type,
3610     arg1: Xmm,
3611     arg2: &XmmMem,
3612 ) -> Option<Xmm> {
3613     let pattern0_0 = arg0;
3614     if pattern0_0 == I8X16 {
3615         let pattern2_0 = arg1;
3616         let pattern3_0 = arg2;
3617         // Rule at src/isa/x64/inst.isle line 2168.
3618         let expr0_0 = constructor_x64_pminsb(ctx, pattern2_0, pattern3_0)?;
3619         return Some(expr0_0);
3620     }
3621     if pattern0_0 == I16X8 {
3622         let pattern2_0 = arg1;
3623         let pattern3_0 = arg2;
3624         // Rule at src/isa/x64/inst.isle line 2169.
3625         let expr0_0 = constructor_x64_pminsw(ctx, pattern2_0, pattern3_0)?;
3626         return Some(expr0_0);
3627     }
3628     if pattern0_0 == I32X4 {
3629         let pattern2_0 = arg1;
3630         let pattern3_0 = arg2;
3631         // Rule at src/isa/x64/inst.isle line 2170.
3632         let expr0_0 = constructor_x64_pminsd(ctx, pattern2_0, pattern3_0)?;
3633         return Some(expr0_0);
3634     }
3635     return None;
3636 }
3637 
3638 // Generated as internal constructor for term x64_pminsb.
3639 pub fn constructor_x64_pminsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3640     let pattern0_0 = arg0;
3641     let pattern1_0 = arg1;
3642     // Rule at src/isa/x64/inst.isle line 2173.
3643     let expr0_0: Type = I8X16;
3644     let expr1_0 = SseOpcode::Pminsb;
3645     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3646     return Some(expr2_0);
3647 }
3648 
3649 // Generated as internal constructor for term x64_pminsw.
3650 pub fn constructor_x64_pminsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3651     let pattern0_0 = arg0;
3652     let pattern1_0 = arg1;
3653     // Rule at src/isa/x64/inst.isle line 2175.
3654     let expr0_0: Type = I16X8;
3655     let expr1_0 = SseOpcode::Pminsw;
3656     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3657     return Some(expr2_0);
3658 }
3659 
3660 // Generated as internal constructor for term x64_pminsd.
3661 pub fn constructor_x64_pminsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3662     let pattern0_0 = arg0;
3663     let pattern1_0 = arg1;
3664     // Rule at src/isa/x64/inst.isle line 2177.
3665     let expr0_0: Type = I32X4;
3666     let expr1_0 = SseOpcode::Pminsd;
3667     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3668     return Some(expr2_0);
3669 }
3670 
3671 // Generated as internal constructor for term x64_pmaxu.
3672 pub fn constructor_x64_pmaxu<C: Context>(
3673     ctx: &mut C,
3674     arg0: Type,
3675     arg1: Xmm,
3676     arg2: &XmmMem,
3677 ) -> Option<Xmm> {
3678     let pattern0_0 = arg0;
3679     if pattern0_0 == I8X16 {
3680         let pattern2_0 = arg1;
3681         let pattern3_0 = arg2;
3682         // Rule at src/isa/x64/inst.isle line 2181.
3683         let expr0_0 = constructor_x64_pmaxub(ctx, pattern2_0, pattern3_0)?;
3684         return Some(expr0_0);
3685     }
3686     if pattern0_0 == I16X8 {
3687         let pattern2_0 = arg1;
3688         let pattern3_0 = arg2;
3689         // Rule at src/isa/x64/inst.isle line 2182.
3690         let expr0_0 = constructor_x64_pmaxuw(ctx, pattern2_0, pattern3_0)?;
3691         return Some(expr0_0);
3692     }
3693     if pattern0_0 == I32X4 {
3694         let pattern2_0 = arg1;
3695         let pattern3_0 = arg2;
3696         // Rule at src/isa/x64/inst.isle line 2183.
3697         let expr0_0 = constructor_x64_pmaxud(ctx, pattern2_0, pattern3_0)?;
3698         return Some(expr0_0);
3699     }
3700     return None;
3701 }
3702 
3703 // Generated as internal constructor for term x64_pmaxub.
3704 pub fn constructor_x64_pmaxub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3705     let pattern0_0 = arg0;
3706     let pattern1_0 = arg1;
3707     // Rule at src/isa/x64/inst.isle line 2186.
3708     let expr0_0: Type = I8X16;
3709     let expr1_0 = SseOpcode::Pmaxub;
3710     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3711     return Some(expr2_0);
3712 }
3713 
3714 // Generated as internal constructor for term x64_pmaxuw.
3715 pub fn constructor_x64_pmaxuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3716     let pattern0_0 = arg0;
3717     let pattern1_0 = arg1;
3718     // Rule at src/isa/x64/inst.isle line 2188.
3719     let expr0_0: Type = I8X16;
3720     let expr1_0 = SseOpcode::Pmaxuw;
3721     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3722     return Some(expr2_0);
3723 }
3724 
3725 // Generated as internal constructor for term x64_pmaxud.
3726 pub fn constructor_x64_pmaxud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3727     let pattern0_0 = arg0;
3728     let pattern1_0 = arg1;
3729     // Rule at src/isa/x64/inst.isle line 2190.
3730     let expr0_0: Type = I8X16;
3731     let expr1_0 = SseOpcode::Pmaxud;
3732     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3733     return Some(expr2_0);
3734 }
3735 
3736 // Generated as internal constructor for term x64_pminu.
3737 pub fn constructor_x64_pminu<C: Context>(
3738     ctx: &mut C,
3739     arg0: Type,
3740     arg1: Xmm,
3741     arg2: &XmmMem,
3742 ) -> Option<Xmm> {
3743     let pattern0_0 = arg0;
3744     if pattern0_0 == I8X16 {
3745         let pattern2_0 = arg1;
3746         let pattern3_0 = arg2;
3747         // Rule at src/isa/x64/inst.isle line 2194.
3748         let expr0_0 = constructor_x64_pminub(ctx, pattern2_0, pattern3_0)?;
3749         return Some(expr0_0);
3750     }
3751     if pattern0_0 == I16X8 {
3752         let pattern2_0 = arg1;
3753         let pattern3_0 = arg2;
3754         // Rule at src/isa/x64/inst.isle line 2195.
3755         let expr0_0 = constructor_x64_pminuw(ctx, pattern2_0, pattern3_0)?;
3756         return Some(expr0_0);
3757     }
3758     if pattern0_0 == I32X4 {
3759         let pattern2_0 = arg1;
3760         let pattern3_0 = arg2;
3761         // Rule at src/isa/x64/inst.isle line 2196.
3762         let expr0_0 = constructor_x64_pminud(ctx, pattern2_0, pattern3_0)?;
3763         return Some(expr0_0);
3764     }
3765     return None;
3766 }
3767 
3768 // Generated as internal constructor for term x64_pminub.
3769 pub fn constructor_x64_pminub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3770     let pattern0_0 = arg0;
3771     let pattern1_0 = arg1;
3772     // Rule at src/isa/x64/inst.isle line 2199.
3773     let expr0_0: Type = I8X16;
3774     let expr1_0 = SseOpcode::Pminub;
3775     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3776     return Some(expr2_0);
3777 }
3778 
3779 // Generated as internal constructor for term x64_pminuw.
3780 pub fn constructor_x64_pminuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3781     let pattern0_0 = arg0;
3782     let pattern1_0 = arg1;
3783     // Rule at src/isa/x64/inst.isle line 2201.
3784     let expr0_0: Type = I8X16;
3785     let expr1_0 = SseOpcode::Pminuw;
3786     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3787     return Some(expr2_0);
3788 }
3789 
3790 // Generated as internal constructor for term x64_pminud.
3791 pub fn constructor_x64_pminud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3792     let pattern0_0 = arg0;
3793     let pattern1_0 = arg1;
3794     // Rule at src/isa/x64/inst.isle line 2203.
3795     let expr0_0: Type = I8X16;
3796     let expr1_0 = SseOpcode::Pminud;
3797     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3798     return Some(expr2_0);
3799 }
3800 
3801 // Generated as internal constructor for term x64_punpcklbw.
3802 pub fn constructor_x64_punpcklbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3803     let pattern0_0 = arg0;
3804     let pattern1_0 = arg1;
3805     // Rule at src/isa/x64/inst.isle line 2207.
3806     let expr0_0: Type = I8X16;
3807     let expr1_0 = SseOpcode::Punpcklbw;
3808     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3809     return Some(expr2_0);
3810 }
3811 
3812 // Generated as internal constructor for term x64_punpckhbw.
3813 pub fn constructor_x64_punpckhbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3814     let pattern0_0 = arg0;
3815     let pattern1_0 = arg1;
3816     // Rule at src/isa/x64/inst.isle line 2212.
3817     let expr0_0: Type = I8X16;
3818     let expr1_0 = SseOpcode::Punpckhbw;
3819     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3820     return Some(expr2_0);
3821 }
3822 
3823 // Generated as internal constructor for term x64_packsswb.
3824 pub fn constructor_x64_packsswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3825     let pattern0_0 = arg0;
3826     let pattern1_0 = arg1;
3827     // Rule at src/isa/x64/inst.isle line 2217.
3828     let expr0_0: Type = I8X16;
3829     let expr1_0 = SseOpcode::Packsswb;
3830     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3831     return Some(expr2_0);
3832 }
3833 
3834 // Generated as internal constructor for term xmm_rm_r_imm.
3835 pub fn constructor_xmm_rm_r_imm<C: Context>(
3836     ctx: &mut C,
3837     arg0: &SseOpcode,
3838     arg1: Reg,
3839     arg2: &RegMem,
3840     arg3: u8,
3841     arg4: &OperandSize,
3842 ) -> Option<Xmm> {
3843     let pattern0_0 = arg0;
3844     let pattern1_0 = arg1;
3845     let pattern2_0 = arg2;
3846     let pattern3_0 = arg3;
3847     let pattern4_0 = arg4;
3848     // Rule at src/isa/x64/inst.isle line 2222.
3849     let expr0_0 = C::temp_writable_xmm(ctx);
3850     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
3851     let expr2_0 = MInst::XmmRmRImm {
3852         op: pattern0_0.clone(),
3853         src1: pattern1_0,
3854         src2: pattern2_0.clone(),
3855         dst: expr1_0,
3856         imm: pattern3_0,
3857         size: pattern4_0.clone(),
3858     };
3859     let expr3_0 = C::emit(ctx, &expr2_0);
3860     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3861     return Some(expr4_0);
3862 }
3863 
3864 // Generated as internal constructor for term x64_palignr.
3865 pub fn constructor_x64_palignr<C: Context>(
3866     ctx: &mut C,
3867     arg0: Xmm,
3868     arg1: &XmmMem,
3869     arg2: u8,
3870     arg3: &OperandSize,
3871 ) -> Option<Xmm> {
3872     let pattern0_0 = arg0;
3873     let pattern1_0 = arg1;
3874     let pattern2_0 = arg2;
3875     let pattern3_0 = arg3;
3876     // Rule at src/isa/x64/inst.isle line 2234.
3877     let expr0_0 = SseOpcode::Palignr;
3878     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3879     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3880     let expr3_0 =
3881         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
3882     return Some(expr3_0);
3883 }
3884 
3885 // Generated as internal constructor for term x64_cmpp.
3886 pub fn constructor_x64_cmpp<C: Context>(
3887     ctx: &mut C,
3888     arg0: Type,
3889     arg1: Xmm,
3890     arg2: &XmmMem,
3891     arg3: &FcmpImm,
3892 ) -> Option<Xmm> {
3893     let pattern0_0 = arg0;
3894     if pattern0_0 == F32X4 {
3895         let pattern2_0 = arg1;
3896         let pattern3_0 = arg2;
3897         let pattern4_0 = arg3;
3898         // Rule at src/isa/x64/inst.isle line 2243.
3899         let expr0_0 = constructor_x64_cmpps(ctx, pattern2_0, pattern3_0, pattern4_0)?;
3900         return Some(expr0_0);
3901     }
3902     if pattern0_0 == F64X2 {
3903         let pattern2_0 = arg1;
3904         let pattern3_0 = arg2;
3905         let pattern4_0 = arg3;
3906         // Rule at src/isa/x64/inst.isle line 2244.
3907         let expr0_0 = constructor_x64_cmppd(ctx, pattern2_0, pattern3_0, pattern4_0)?;
3908         return Some(expr0_0);
3909     }
3910     return None;
3911 }
3912 
3913 // Generated as internal constructor for term x64_cmpps.
3914 pub fn constructor_x64_cmpps<C: Context>(
3915     ctx: &mut C,
3916     arg0: Xmm,
3917     arg1: &XmmMem,
3918     arg2: &FcmpImm,
3919 ) -> Option<Xmm> {
3920     let pattern0_0 = arg0;
3921     let pattern1_0 = arg1;
3922     let pattern2_0 = arg2;
3923     // Rule at src/isa/x64/inst.isle line 2247.
3924     let expr0_0 = SseOpcode::Cmpps;
3925     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3926     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3927     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
3928     let expr4_0 = OperandSize::Size32;
3929     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
3930     return Some(expr5_0);
3931 }
3932 
3933 // Generated as internal constructor for term x64_cmppd.
3934 pub fn constructor_x64_cmppd<C: Context>(
3935     ctx: &mut C,
3936     arg0: Xmm,
3937     arg1: &XmmMem,
3938     arg2: &FcmpImm,
3939 ) -> Option<Xmm> {
3940     let pattern0_0 = arg0;
3941     let pattern1_0 = arg1;
3942     let pattern2_0 = arg2;
3943     // Rule at src/isa/x64/inst.isle line 2258.
3944     let expr0_0 = SseOpcode::Cmppd;
3945     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3946     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3947     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
3948     let expr4_0 = OperandSize::Size32;
3949     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
3950     return Some(expr5_0);
3951 }
3952 
3953 // Generated as internal constructor for term x64_pinsrb.
3954 pub fn constructor_x64_pinsrb<C: Context>(
3955     ctx: &mut C,
3956     arg0: Xmm,
3957     arg1: &GprMem,
3958     arg2: u8,
3959 ) -> Option<Xmm> {
3960     let pattern0_0 = arg0;
3961     let pattern1_0 = arg1;
3962     let pattern2_0 = arg2;
3963     // Rule at src/isa/x64/inst.isle line 2267.
3964     let expr0_0 = SseOpcode::Pinsrb;
3965     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3966     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3967     let expr3_0 = OperandSize::Size32;
3968     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3969     return Some(expr4_0);
3970 }
3971 
3972 // Generated as internal constructor for term x64_pinsrw.
3973 pub fn constructor_x64_pinsrw<C: Context>(
3974     ctx: &mut C,
3975     arg0: Xmm,
3976     arg1: &GprMem,
3977     arg2: u8,
3978 ) -> Option<Xmm> {
3979     let pattern0_0 = arg0;
3980     let pattern1_0 = arg1;
3981     let pattern2_0 = arg2;
3982     // Rule at src/isa/x64/inst.isle line 2276.
3983     let expr0_0 = SseOpcode::Pinsrw;
3984     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3985     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3986     let expr3_0 = OperandSize::Size32;
3987     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3988     return Some(expr4_0);
3989 }
3990 
3991 // Generated as internal constructor for term x64_pinsrd.
3992 pub fn constructor_x64_pinsrd<C: Context>(
3993     ctx: &mut C,
3994     arg0: Xmm,
3995     arg1: &GprMem,
3996     arg2: u8,
3997     arg3: &OperandSize,
3998 ) -> Option<Xmm> {
3999     let pattern0_0 = arg0;
4000     let pattern1_0 = arg1;
4001     let pattern2_0 = arg2;
4002     let pattern3_0 = arg3;
4003     // Rule at src/isa/x64/inst.isle line 2285.
4004     let expr0_0 = SseOpcode::Pinsrd;
4005     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
4006     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
4007     let expr3_0 =
4008         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
4009     return Some(expr3_0);
4010 }
4011 
4012 // Generated as internal constructor for term x64_pmaddwd.
4013 pub fn constructor_x64_pmaddwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4014     let pattern0_0 = arg0;
4015     let pattern1_0 = arg1;
4016     // Rule at src/isa/x64/inst.isle line 2294.
4017     let expr0_0 = C::temp_writable_xmm(ctx);
4018     let expr1_0 = SseOpcode::Pmaddwd;
4019     let expr2_0 = MInst::XmmRmR {
4020         op: expr1_0,
4021         src1: pattern0_0,
4022         src2: pattern1_0.clone(),
4023         dst: expr0_0,
4024     };
4025     let expr3_0 = C::emit(ctx, &expr2_0);
4026     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4027     return Some(expr4_0);
4028 }
4029 
4030 // Generated as internal constructor for term x64_insertps.
4031 pub fn constructor_x64_insertps<C: Context>(
4032     ctx: &mut C,
4033     arg0: Xmm,
4034     arg1: &XmmMem,
4035     arg2: u8,
4036 ) -> Option<Xmm> {
4037     let pattern0_0 = arg0;
4038     let pattern1_0 = arg1;
4039     let pattern2_0 = arg2;
4040     // Rule at src/isa/x64/inst.isle line 2304.
4041     let expr0_0 = SseOpcode::Insertps;
4042     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
4043     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
4044     let expr3_0 = OperandSize::Size32;
4045     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
4046     return Some(expr4_0);
4047 }
4048 
4049 // Generated as internal constructor for term x64_pshufd.
4050 pub fn constructor_x64_pshufd<C: Context>(
4051     ctx: &mut C,
4052     arg0: &XmmMem,
4053     arg1: u8,
4054     arg2: &OperandSize,
4055 ) -> Option<Xmm> {
4056     let pattern0_0 = arg0;
4057     let pattern1_0 = arg1;
4058     let pattern2_0 = arg2;
4059     // Rule at src/isa/x64/inst.isle line 2313.
4060     let expr0_0 = C::temp_writable_xmm(ctx);
4061     let expr1_0 = SseOpcode::Pshufd;
4062     let expr2_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
4063     let expr3_0 = C::xmm_mem_to_reg_mem(ctx, pattern0_0);
4064     let expr4_0 = C::writable_xmm_to_reg(ctx, expr0_0);
4065     let expr5_0 = MInst::XmmRmRImm {
4066         op: expr1_0,
4067         src1: expr2_0,
4068         src2: expr3_0,
4069         dst: expr4_0,
4070         imm: pattern1_0,
4071         size: pattern2_0.clone(),
4072     };
4073     let expr6_0 = C::emit(ctx, &expr5_0);
4074     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4075     return Some(expr7_0);
4076 }
4077 
4078 // Generated as internal constructor for term x64_pshufb.
4079 pub fn constructor_x64_pshufb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4080     let pattern0_0 = arg0;
4081     let pattern1_0 = arg1;
4082     // Rule at src/isa/x64/inst.isle line 2325.
4083     let expr0_0 = C::temp_writable_xmm(ctx);
4084     let expr1_0 = SseOpcode::Pshufb;
4085     let expr2_0 = MInst::XmmRmR {
4086         op: expr1_0,
4087         src1: pattern0_0,
4088         src2: pattern1_0.clone(),
4089         dst: expr0_0,
4090     };
4091     let expr3_0 = C::emit(ctx, &expr2_0);
4092     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4093     return Some(expr4_0);
4094 }
4095 
4096 // Generated as internal constructor for term xmm_unary_rm_r.
4097 pub fn constructor_xmm_unary_rm_r<C: Context>(
4098     ctx: &mut C,
4099     arg0: &SseOpcode,
4100     arg1: &XmmMem,
4101 ) -> Option<Xmm> {
4102     let pattern0_0 = arg0;
4103     let pattern1_0 = arg1;
4104     // Rule at src/isa/x64/inst.isle line 2335.
4105     let expr0_0 = C::temp_writable_xmm(ctx);
4106     let expr1_0 = MInst::XmmUnaryRmR {
4107         op: pattern0_0.clone(),
4108         src: pattern1_0.clone(),
4109         dst: expr0_0,
4110     };
4111     let expr2_0 = C::emit(ctx, &expr1_0);
4112     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4113     return Some(expr3_0);
4114 }
4115 
4116 // Generated as internal constructor for term x64_pabsb.
4117 pub fn constructor_x64_pabsb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4118     let pattern0_0 = arg0;
4119     // Rule at src/isa/x64/inst.isle line 2342.
4120     let expr0_0 = SseOpcode::Pabsb;
4121     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4122     return Some(expr1_0);
4123 }
4124 
4125 // Generated as internal constructor for term x64_pabsw.
4126 pub fn constructor_x64_pabsw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4127     let pattern0_0 = arg0;
4128     // Rule at src/isa/x64/inst.isle line 2347.
4129     let expr0_0 = SseOpcode::Pabsw;
4130     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4131     return Some(expr1_0);
4132 }
4133 
4134 // Generated as internal constructor for term x64_pabsd.
4135 pub fn constructor_x64_pabsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4136     let pattern0_0 = arg0;
4137     // Rule at src/isa/x64/inst.isle line 2352.
4138     let expr0_0 = SseOpcode::Pabsd;
4139     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4140     return Some(expr1_0);
4141 }
4142 
4143 // Generated as internal constructor for term xmm_unary_rm_r_evex.
4144 pub fn constructor_xmm_unary_rm_r_evex<C: Context>(
4145     ctx: &mut C,
4146     arg0: &Avx512Opcode,
4147     arg1: &XmmMem,
4148 ) -> Option<Xmm> {
4149     let pattern0_0 = arg0;
4150     let pattern1_0 = arg1;
4151     // Rule at src/isa/x64/inst.isle line 2357.
4152     let expr0_0 = C::temp_writable_xmm(ctx);
4153     let expr1_0 = MInst::XmmUnaryRmREvex {
4154         op: pattern0_0.clone(),
4155         src: pattern1_0.clone(),
4156         dst: expr0_0,
4157     };
4158     let expr2_0 = C::emit(ctx, &expr1_0);
4159     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4160     return Some(expr3_0);
4161 }
4162 
4163 // Generated as internal constructor for term x64_vpabsq.
4164 pub fn constructor_x64_vpabsq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4165     let pattern0_0 = arg0;
4166     // Rule at src/isa/x64/inst.isle line 2364.
4167     let expr0_0 = Avx512Opcode::Vpabsq;
4168     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4169     return Some(expr1_0);
4170 }
4171 
4172 // Generated as internal constructor for term x64_vpopcntb.
4173 pub fn constructor_x64_vpopcntb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4174     let pattern0_0 = arg0;
4175     // Rule at src/isa/x64/inst.isle line 2369.
4176     let expr0_0 = Avx512Opcode::Vpopcntb;
4177     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4178     return Some(expr1_0);
4179 }
4180 
4181 // Generated as internal constructor for term xmm_rm_r_evex.
4182 pub fn constructor_xmm_rm_r_evex<C: Context>(
4183     ctx: &mut C,
4184     arg0: &Avx512Opcode,
4185     arg1: &XmmMem,
4186     arg2: Xmm,
4187 ) -> Option<Xmm> {
4188     let pattern0_0 = arg0;
4189     let pattern1_0 = arg1;
4190     let pattern2_0 = arg2;
4191     // Rule at src/isa/x64/inst.isle line 2374.
4192     let expr0_0 = C::temp_writable_xmm(ctx);
4193     let expr1_0 = MInst::XmmRmREvex {
4194         op: pattern0_0.clone(),
4195         src1: pattern1_0.clone(),
4196         src2: pattern2_0,
4197         dst: expr0_0,
4198     };
4199     let expr2_0 = C::emit(ctx, &expr1_0);
4200     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4201     return Some(expr3_0);
4202 }
4203 
4204 // Generated as internal constructor for term x64_vpmullq.
4205 pub fn constructor_x64_vpmullq<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> Option<Xmm> {
4206     let pattern0_0 = arg0;
4207     let pattern1_0 = arg1;
4208     // Rule at src/isa/x64/inst.isle line 2386.
4209     let expr0_0 = Avx512Opcode::Vpmullq;
4210     let expr1_0 = constructor_xmm_rm_r_evex(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4211     return Some(expr1_0);
4212 }
4213 
4214 // Generated as internal constructor for term mul_hi.
4215 pub fn constructor_mul_hi<C: Context>(
4216     ctx: &mut C,
4217     arg0: Type,
4218     arg1: bool,
4219     arg2: Gpr,
4220     arg3: &GprMem,
4221 ) -> Option<ValueRegs> {
4222     let pattern0_0 = arg0;
4223     let pattern1_0 = arg1;
4224     let pattern2_0 = arg2;
4225     let pattern3_0 = arg3;
4226     // Rule at src/isa/x64/inst.isle line 2395.
4227     let expr0_0 = C::temp_writable_gpr(ctx);
4228     let expr1_0 = C::temp_writable_gpr(ctx);
4229     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4230     let expr3_0 = MInst::MulHi {
4231         size: expr2_0,
4232         signed: pattern1_0,
4233         src1: pattern2_0,
4234         src2: pattern3_0.clone(),
4235         dst_lo: expr0_0,
4236         dst_hi: expr1_0,
4237     };
4238     let expr4_0 = C::emit(ctx, &expr3_0);
4239     let expr5_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4240     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
4241     let expr7_0 = constructor_value_gprs(ctx, expr5_0, expr6_0)?;
4242     return Some(expr7_0);
4243 }
4244 
4245 // Generated as internal constructor for term mulhi_u.
4246 pub fn constructor_mulhi_u<C: Context>(
4247     ctx: &mut C,
4248     arg0: Type,
4249     arg1: Gpr,
4250     arg2: &GprMem,
4251 ) -> Option<ValueRegs> {
4252     let pattern0_0 = arg0;
4253     let pattern1_0 = arg1;
4254     let pattern2_0 = arg2;
4255     // Rule at src/isa/x64/inst.isle line 2410.
4256     let expr0_0: bool = false;
4257     let expr1_0 = constructor_mul_hi(ctx, pattern0_0, expr0_0, pattern1_0, pattern2_0)?;
4258     return Some(expr1_0);
4259 }
4260 
4261 // Generated as internal constructor for term xmm_rmi_xmm.
4262 pub fn constructor_xmm_rmi_xmm<C: Context>(
4263     ctx: &mut C,
4264     arg0: &SseOpcode,
4265     arg1: Xmm,
4266     arg2: &XmmMemImm,
4267 ) -> Option<Xmm> {
4268     let pattern0_0 = arg0;
4269     let pattern1_0 = arg1;
4270     let pattern2_0 = arg2;
4271     // Rule at src/isa/x64/inst.isle line 2415.
4272     let expr0_0 = C::temp_writable_xmm(ctx);
4273     let expr1_0 = MInst::XmmRmiReg {
4274         opcode: pattern0_0.clone(),
4275         src1: pattern1_0,
4276         src2: pattern2_0.clone(),
4277         dst: expr0_0,
4278     };
4279     let expr2_0 = C::emit(ctx, &expr1_0);
4280     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4281     return Some(expr3_0);
4282 }
4283 
4284 // Generated as internal constructor for term x64_psllw.
4285 pub fn constructor_x64_psllw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4286     let pattern0_0 = arg0;
4287     let pattern1_0 = arg1;
4288     // Rule at src/isa/x64/inst.isle line 2425.
4289     let expr0_0 = SseOpcode::Psllw;
4290     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4291     return Some(expr1_0);
4292 }
4293 
4294 // Generated as internal constructor for term x64_pslld.
4295 pub fn constructor_x64_pslld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4296     let pattern0_0 = arg0;
4297     let pattern1_0 = arg1;
4298     // Rule at src/isa/x64/inst.isle line 2430.
4299     let expr0_0 = SseOpcode::Pslld;
4300     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4301     return Some(expr1_0);
4302 }
4303 
4304 // Generated as internal constructor for term x64_psllq.
4305 pub fn constructor_x64_psllq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4306     let pattern0_0 = arg0;
4307     let pattern1_0 = arg1;
4308     // Rule at src/isa/x64/inst.isle line 2435.
4309     let expr0_0 = SseOpcode::Psllq;
4310     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4311     return Some(expr1_0);
4312 }
4313 
4314 // Generated as internal constructor for term x64_psrlw.
4315 pub fn constructor_x64_psrlw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4316     let pattern0_0 = arg0;
4317     let pattern1_0 = arg1;
4318     // Rule at src/isa/x64/inst.isle line 2440.
4319     let expr0_0 = SseOpcode::Psrlw;
4320     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4321     return Some(expr1_0);
4322 }
4323 
4324 // Generated as internal constructor for term x64_psrld.
4325 pub fn constructor_x64_psrld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4326     let pattern0_0 = arg0;
4327     let pattern1_0 = arg1;
4328     // Rule at src/isa/x64/inst.isle line 2445.
4329     let expr0_0 = SseOpcode::Psrld;
4330     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4331     return Some(expr1_0);
4332 }
4333 
4334 // Generated as internal constructor for term x64_psrlq.
4335 pub fn constructor_x64_psrlq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4336     let pattern0_0 = arg0;
4337     let pattern1_0 = arg1;
4338     // Rule at src/isa/x64/inst.isle line 2450.
4339     let expr0_0 = SseOpcode::Psrlq;
4340     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4341     return Some(expr1_0);
4342 }
4343 
4344 // Generated as internal constructor for term x64_psraw.
4345 pub fn constructor_x64_psraw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4346     let pattern0_0 = arg0;
4347     let pattern1_0 = arg1;
4348     // Rule at src/isa/x64/inst.isle line 2455.
4349     let expr0_0 = SseOpcode::Psraw;
4350     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4351     return Some(expr1_0);
4352 }
4353 
4354 // Generated as internal constructor for term x64_psrad.
4355 pub fn constructor_x64_psrad<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4356     let pattern0_0 = arg0;
4357     let pattern1_0 = arg1;
4358     // Rule at src/isa/x64/inst.isle line 2460.
4359     let expr0_0 = SseOpcode::Psrad;
4360     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4361     return Some(expr1_0);
4362 }
4363 
4364 // Generated as internal constructor for term x64_pextrd.
4365 pub fn constructor_x64_pextrd<C: Context>(
4366     ctx: &mut C,
4367     arg0: Type,
4368     arg1: Xmm,
4369     arg2: u8,
4370 ) -> Option<Gpr> {
4371     let pattern0_0 = arg0;
4372     let pattern1_0 = arg1;
4373     let pattern2_0 = arg2;
4374     // Rule at src/isa/x64/inst.isle line 2465.
4375     let expr0_0 = C::temp_writable_gpr(ctx);
4376     let expr1_0 = SseOpcode::Pextrd;
4377     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4378     let expr3_0 = C::xmm_to_reg(ctx, pattern1_0);
4379     let expr4_0 = constructor_xmm_to_reg_mem(ctx, expr3_0)?;
4380     let expr5_0 = C::xmm_mem_to_reg_mem(ctx, &expr4_0);
4381     let expr6_0 = C::writable_gpr_to_reg(ctx, expr0_0);
4382     let expr7_0 = C::lane_type(ctx, pattern0_0);
4383     let expr8_0 = C::operand_size_of_type_32_64(ctx, expr7_0);
4384     let expr9_0 = MInst::XmmRmRImm {
4385         op: expr1_0,
4386         src1: expr2_0,
4387         src2: expr5_0,
4388         dst: expr6_0,
4389         imm: pattern2_0,
4390         size: expr8_0,
4391     };
4392     let expr10_0 = C::emit(ctx, &expr9_0);
4393     let expr11_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4394     return Some(expr11_0);
4395 }
4396 
4397 // Generated as internal constructor for term gpr_to_xmm.
4398 pub fn constructor_gpr_to_xmm<C: Context>(
4399     ctx: &mut C,
4400     arg0: &SseOpcode,
4401     arg1: &GprMem,
4402     arg2: &OperandSize,
4403 ) -> Option<Xmm> {
4404     let pattern0_0 = arg0;
4405     let pattern1_0 = arg1;
4406     let pattern2_0 = arg2;
4407     // Rule at src/isa/x64/inst.isle line 2477.
4408     let expr0_0 = C::temp_writable_xmm(ctx);
4409     let expr1_0 = MInst::GprToXmm {
4410         op: pattern0_0.clone(),
4411         src: pattern1_0.clone(),
4412         dst: expr0_0,
4413         src_size: pattern2_0.clone(),
4414     };
4415     let expr2_0 = C::emit(ctx, &expr1_0);
4416     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4417     return Some(expr3_0);
4418 }
4419 
4420 // Generated as internal constructor for term x64_not.
4421 pub fn constructor_x64_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4422     let pattern0_0 = arg0;
4423     let pattern1_0 = arg1;
4424     // Rule at src/isa/x64/inst.isle line 2484.
4425     let expr0_0 = C::temp_writable_gpr(ctx);
4426     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4427     let expr2_0 = MInst::Not {
4428         size: expr1_0,
4429         src: pattern1_0,
4430         dst: expr0_0,
4431     };
4432     let expr3_0 = C::emit(ctx, &expr2_0);
4433     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4434     return Some(expr4_0);
4435 }
4436 
4437 // Generated as internal constructor for term x64_neg.
4438 pub fn constructor_x64_neg<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4439     let pattern0_0 = arg0;
4440     let pattern1_0 = arg1;
4441     // Rule at src/isa/x64/inst.isle line 2492.
4442     let expr0_0 = C::temp_writable_gpr(ctx);
4443     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4444     let expr2_0 = MInst::Neg {
4445         size: expr1_0,
4446         src: pattern1_0,
4447         dst: expr0_0,
4448     };
4449     let expr3_0 = C::emit(ctx, &expr2_0);
4450     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4451     return Some(expr4_0);
4452 }
4453 
4454 // Generated as internal constructor for term x64_lea.
4455 pub fn constructor_x64_lea<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Option<Gpr> {
4456     let pattern0_0 = arg0;
4457     // Rule at src/isa/x64/inst.isle line 2499.
4458     let expr0_0 = C::temp_writable_gpr(ctx);
4459     let expr1_0 = MInst::LoadEffectiveAddress {
4460         addr: pattern0_0.clone(),
4461         dst: expr0_0,
4462     };
4463     let expr2_0 = C::emit(ctx, &expr1_0);
4464     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4465     return Some(expr3_0);
4466 }
4467 
4468 // Generated as internal constructor for term x64_ud2.
4469 pub fn constructor_x64_ud2<C: Context>(ctx: &mut C, arg0: &TrapCode) -> Option<SideEffectNoResult> {
4470     let pattern0_0 = arg0;
4471     // Rule at src/isa/x64/inst.isle line 2506.
4472     let expr0_0 = MInst::Ud2 {
4473         trap_code: pattern0_0.clone(),
4474     };
4475     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4476     return Some(expr1_0);
4477 }
4478 
4479 // Generated as internal constructor for term x64_hlt.
4480 pub fn constructor_x64_hlt<C: Context>(ctx: &mut C) -> Option<SideEffectNoResult> {
4481     // Rule at src/isa/x64/inst.isle line 2511.
4482     let expr0_0 = MInst::Hlt;
4483     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4484     return Some(expr1_0);
4485 }
4486 
4487 // Generated as internal constructor for term x64_lzcnt.
4488 pub fn constructor_x64_lzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4489     let pattern0_0 = arg0;
4490     let pattern1_0 = arg1;
4491     // Rule at src/isa/x64/inst.isle line 2516.
4492     let expr0_0 = C::temp_writable_gpr(ctx);
4493     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4494     let expr2_0 = UnaryRmROpcode::Lzcnt;
4495     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4496     let expr4_0 = MInst::UnaryRmR {
4497         size: expr1_0,
4498         op: expr2_0,
4499         src: expr3_0,
4500         dst: expr0_0,
4501     };
4502     let expr5_0 = C::emit(ctx, &expr4_0);
4503     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4504     return Some(expr6_0);
4505 }
4506 
4507 // Generated as internal constructor for term x64_tzcnt.
4508 pub fn constructor_x64_tzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4509     let pattern0_0 = arg0;
4510     let pattern1_0 = arg1;
4511     // Rule at src/isa/x64/inst.isle line 2524.
4512     let expr0_0 = C::temp_writable_gpr(ctx);
4513     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4514     let expr2_0 = UnaryRmROpcode::Tzcnt;
4515     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4516     let expr4_0 = MInst::UnaryRmR {
4517         size: expr1_0,
4518         op: expr2_0,
4519         src: expr3_0,
4520         dst: expr0_0,
4521     };
4522     let expr5_0 = C::emit(ctx, &expr4_0);
4523     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4524     return Some(expr6_0);
4525 }
4526 
4527 // Generated as internal constructor for term x64_bsr.
4528 pub fn constructor_x64_bsr<C: Context>(
4529     ctx: &mut C,
4530     arg0: Type,
4531     arg1: Gpr,
4532 ) -> Option<ProducesFlags> {
4533     let pattern0_0 = arg0;
4534     let pattern1_0 = arg1;
4535     // Rule at src/isa/x64/inst.isle line 2532.
4536     let expr0_0 = C::temp_writable_gpr(ctx);
4537     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4538     let expr2_0 = UnaryRmROpcode::Bsr;
4539     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4540     let expr4_0 = MInst::UnaryRmR {
4541         size: expr1_0,
4542         op: expr2_0,
4543         src: expr3_0,
4544         dst: expr0_0,
4545     };
4546     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4547     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4548         inst: expr4_0,
4549         result: expr5_0,
4550     };
4551     return Some(expr6_0);
4552 }
4553 
4554 // Generated as internal constructor for term bsr_or_else.
4555 pub fn constructor_bsr_or_else<C: Context>(
4556     ctx: &mut C,
4557     arg0: Type,
4558     arg1: Gpr,
4559     arg2: Gpr,
4560 ) -> Option<Gpr> {
4561     let pattern0_0 = arg0;
4562     let pattern1_0 = arg1;
4563     let pattern2_0 = arg2;
4564     // Rule at src/isa/x64/inst.isle line 2541.
4565     let expr0_0 = constructor_x64_bsr(ctx, pattern0_0, pattern1_0)?;
4566     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4567     let expr2_0 = C::gpr_new(ctx, expr1_0);
4568     let expr3_0 = CC::Z;
4569     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4570     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4571     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4572     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4573     let expr8_0 = C::gpr_new(ctx, expr7_0);
4574     return Some(expr8_0);
4575 }
4576 
4577 // Generated as internal constructor for term x64_bsf.
4578 pub fn constructor_x64_bsf<C: Context>(
4579     ctx: &mut C,
4580     arg0: Type,
4581     arg1: Gpr,
4582 ) -> Option<ProducesFlags> {
4583     let pattern0_0 = arg0;
4584     let pattern1_0 = arg1;
4585     // Rule at src/isa/x64/inst.isle line 2552.
4586     let expr0_0 = C::temp_writable_gpr(ctx);
4587     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4588     let expr2_0 = UnaryRmROpcode::Bsf;
4589     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4590     let expr4_0 = MInst::UnaryRmR {
4591         size: expr1_0,
4592         op: expr2_0,
4593         src: expr3_0,
4594         dst: expr0_0,
4595     };
4596     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4597     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4598         inst: expr4_0,
4599         result: expr5_0,
4600     };
4601     return Some(expr6_0);
4602 }
4603 
4604 // Generated as internal constructor for term bsf_or_else.
4605 pub fn constructor_bsf_or_else<C: Context>(
4606     ctx: &mut C,
4607     arg0: Type,
4608     arg1: Gpr,
4609     arg2: Gpr,
4610 ) -> Option<Gpr> {
4611     let pattern0_0 = arg0;
4612     let pattern1_0 = arg1;
4613     let pattern2_0 = arg2;
4614     // Rule at src/isa/x64/inst.isle line 2561.
4615     let expr0_0 = constructor_x64_bsf(ctx, pattern0_0, pattern1_0)?;
4616     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4617     let expr2_0 = C::gpr_new(ctx, expr1_0);
4618     let expr3_0 = CC::Z;
4619     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4620     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4621     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4622     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4623     let expr8_0 = C::gpr_new(ctx, expr7_0);
4624     return Some(expr8_0);
4625 }
4626 
4627 // Generated as internal constructor for term x64_popcnt.
4628 pub fn constructor_x64_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4629     let pattern0_0 = arg0;
4630     let pattern1_0 = arg1;
4631     // Rule at src/isa/x64/inst.isle line 2572.
4632     let expr0_0 = C::temp_writable_gpr(ctx);
4633     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4634     let expr2_0 = UnaryRmROpcode::Popcnt;
4635     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4636     let expr4_0 = MInst::UnaryRmR {
4637         size: expr1_0,
4638         op: expr2_0,
4639         src: expr3_0,
4640         dst: expr0_0,
4641     };
4642     let expr5_0 = C::emit(ctx, &expr4_0);
4643     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4644     return Some(expr6_0);
4645 }
4646 
4647 // Generated as internal constructor for term xmm_min_max_seq.
4648 pub fn constructor_xmm_min_max_seq<C: Context>(
4649     ctx: &mut C,
4650     arg0: Type,
4651     arg1: bool,
4652     arg2: Xmm,
4653     arg3: Xmm,
4654 ) -> Option<Xmm> {
4655     let pattern0_0 = arg0;
4656     let pattern1_0 = arg1;
4657     let pattern2_0 = arg2;
4658     let pattern3_0 = arg3;
4659     // Rule at src/isa/x64/inst.isle line 2580.
4660     let expr0_0 = C::temp_writable_xmm(ctx);
4661     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4662     let expr2_0 = MInst::XmmMinMaxSeq {
4663         size: expr1_0,
4664         is_min: pattern1_0,
4665         lhs: pattern2_0,
4666         rhs: pattern3_0,
4667         dst: expr0_0,
4668     };
4669     let expr3_0 = C::emit(ctx, &expr2_0);
4670     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4671     return Some(expr4_0);
4672 }
4673 
4674 // Generated as internal constructor for term x64_minss.
4675 pub fn constructor_x64_minss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4676     let pattern0_0 = arg0;
4677     let pattern1_0 = arg1;
4678     // Rule at src/isa/x64/inst.isle line 2588.
4679     let expr0_0 = C::temp_writable_xmm(ctx);
4680     let expr1_0 = SseOpcode::Minss;
4681     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4682     let expr3_0 = MInst::XmmRmR {
4683         op: expr1_0,
4684         src1: pattern0_0,
4685         src2: expr2_0,
4686         dst: expr0_0,
4687     };
4688     let expr4_0 = C::emit(ctx, &expr3_0);
4689     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4690     return Some(expr5_0);
4691 }
4692 
4693 // Generated as internal constructor for term x64_minsd.
4694 pub fn constructor_x64_minsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4695     let pattern0_0 = arg0;
4696     let pattern1_0 = arg1;
4697     // Rule at src/isa/x64/inst.isle line 2595.
4698     let expr0_0 = C::temp_writable_xmm(ctx);
4699     let expr1_0 = SseOpcode::Minsd;
4700     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4701     let expr3_0 = MInst::XmmRmR {
4702         op: expr1_0,
4703         src1: pattern0_0,
4704         src2: expr2_0,
4705         dst: expr0_0,
4706     };
4707     let expr4_0 = C::emit(ctx, &expr3_0);
4708     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4709     return Some(expr5_0);
4710 }
4711 
4712 // Generated as internal constructor for term x64_minps.
4713 pub fn constructor_x64_minps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4714     let pattern0_0 = arg0;
4715     let pattern1_0 = arg1;
4716     // Rule at src/isa/x64/inst.isle line 2603.
4717     let expr0_0 = C::temp_writable_xmm(ctx);
4718     let expr1_0 = SseOpcode::Minps;
4719     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4720     let expr3_0 = MInst::XmmRmR {
4721         op: expr1_0,
4722         src1: pattern0_0,
4723         src2: expr2_0,
4724         dst: expr0_0,
4725     };
4726     let expr4_0 = C::emit(ctx, &expr3_0);
4727     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4728     return Some(expr5_0);
4729 }
4730 
4731 // Generated as internal constructor for term x64_minpd.
4732 pub fn constructor_x64_minpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4733     let pattern0_0 = arg0;
4734     let pattern1_0 = arg1;
4735     // Rule at src/isa/x64/inst.isle line 2610.
4736     let expr0_0 = C::temp_writable_xmm(ctx);
4737     let expr1_0 = SseOpcode::Minpd;
4738     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4739     let expr3_0 = MInst::XmmRmR {
4740         op: expr1_0,
4741         src1: pattern0_0,
4742         src2: expr2_0,
4743         dst: expr0_0,
4744     };
4745     let expr4_0 = C::emit(ctx, &expr3_0);
4746     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4747     return Some(expr5_0);
4748 }
4749 
4750 // Generated as internal constructor for term x64_maxss.
4751 pub fn constructor_x64_maxss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4752     let pattern0_0 = arg0;
4753     let pattern1_0 = arg1;
4754     // Rule at src/isa/x64/inst.isle line 2617.
4755     let expr0_0 = C::temp_writable_xmm(ctx);
4756     let expr1_0 = SseOpcode::Maxss;
4757     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4758     let expr3_0 = MInst::XmmRmR {
4759         op: expr1_0,
4760         src1: pattern0_0,
4761         src2: expr2_0,
4762         dst: expr0_0,
4763     };
4764     let expr4_0 = C::emit(ctx, &expr3_0);
4765     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4766     return Some(expr5_0);
4767 }
4768 
4769 // Generated as internal constructor for term x64_maxsd.
4770 pub fn constructor_x64_maxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4771     let pattern0_0 = arg0;
4772     let pattern1_0 = arg1;
4773     // Rule at src/isa/x64/inst.isle line 2624.
4774     let expr0_0 = C::temp_writable_xmm(ctx);
4775     let expr1_0 = SseOpcode::Maxsd;
4776     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4777     let expr3_0 = MInst::XmmRmR {
4778         op: expr1_0,
4779         src1: pattern0_0,
4780         src2: expr2_0,
4781         dst: expr0_0,
4782     };
4783     let expr4_0 = C::emit(ctx, &expr3_0);
4784     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4785     return Some(expr5_0);
4786 }
4787 
4788 // Generated as internal constructor for term x64_maxps.
4789 pub fn constructor_x64_maxps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4790     let pattern0_0 = arg0;
4791     let pattern1_0 = arg1;
4792     // Rule at src/isa/x64/inst.isle line 2631.
4793     let expr0_0 = C::temp_writable_xmm(ctx);
4794     let expr1_0 = SseOpcode::Maxps;
4795     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4796     let expr3_0 = MInst::XmmRmR {
4797         op: expr1_0,
4798         src1: pattern0_0,
4799         src2: expr2_0,
4800         dst: expr0_0,
4801     };
4802     let expr4_0 = C::emit(ctx, &expr3_0);
4803     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4804     return Some(expr5_0);
4805 }
4806 
4807 // Generated as internal constructor for term x64_maxpd.
4808 pub fn constructor_x64_maxpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4809     let pattern0_0 = arg0;
4810     let pattern1_0 = arg1;
4811     // Rule at src/isa/x64/inst.isle line 2638.
4812     let expr0_0 = C::temp_writable_xmm(ctx);
4813     let expr1_0 = SseOpcode::Maxpd;
4814     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4815     let expr3_0 = MInst::XmmRmR {
4816         op: expr1_0,
4817         src1: pattern0_0,
4818         src2: expr2_0,
4819         dst: expr0_0,
4820     };
4821     let expr4_0 = C::emit(ctx, &expr3_0);
4822     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4823     return Some(expr5_0);
4824 }
4825 
4826 // Generated as internal constructor for term x64_sqrtss.
4827 pub fn constructor_x64_sqrtss<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
4828     let pattern0_0 = arg0;
4829     // Rule at src/isa/x64/inst.isle line 2646.
4830     let expr0_0 = C::temp_writable_xmm(ctx);
4831     let expr1_0 = SseOpcode::Sqrtss;
4832     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
4833     let expr3_0 = MInst::XmmUnaryRmR {
4834         op: expr1_0,
4835         src: expr2_0,
4836         dst: expr0_0,
4837     };
4838     let expr4_0 = C::emit(ctx, &expr3_0);
4839     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4840     return Some(expr5_0);
4841 }
4842 
4843 // Generated as internal constructor for term x64_sqrtsd.
4844 pub fn constructor_x64_sqrtsd<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
4845     let pattern0_0 = arg0;
4846     // Rule at src/isa/x64/inst.isle line 2653.
4847     let expr0_0 = C::temp_writable_xmm(ctx);
4848     let expr1_0 = SseOpcode::Sqrtsd;
4849     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
4850     let expr3_0 = MInst::XmmUnaryRmR {
4851         op: expr1_0,
4852         src: expr2_0,
4853         dst: expr0_0,
4854     };
4855     let expr4_0 = C::emit(ctx, &expr3_0);
4856     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4857     return Some(expr5_0);
4858 }
4859 
4860 // Generated as internal constructor for term x64_sqrtps.
4861 pub fn constructor_x64_sqrtps<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
4862     let pattern0_0 = arg0;
4863     // Rule at src/isa/x64/inst.isle line 2660.
4864     let expr0_0 = C::temp_writable_xmm(ctx);
4865     let expr1_0 = SseOpcode::Sqrtps;
4866     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
4867     let expr3_0 = MInst::XmmUnaryRmR {
4868         op: expr1_0,
4869         src: expr2_0,
4870         dst: expr0_0,
4871     };
4872     let expr4_0 = C::emit(ctx, &expr3_0);
4873     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4874     return Some(expr5_0);
4875 }
4876 
4877 // Generated as internal constructor for term x64_sqrtpd.
4878 pub fn constructor_x64_sqrtpd<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
4879     let pattern0_0 = arg0;
4880     // Rule at src/isa/x64/inst.isle line 2667.
4881     let expr0_0 = C::temp_writable_xmm(ctx);
4882     let expr1_0 = SseOpcode::Sqrtpd;
4883     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
4884     let expr3_0 = MInst::XmmUnaryRmR {
4885         op: expr1_0,
4886         src: expr2_0,
4887         dst: expr0_0,
4888     };
4889     let expr4_0 = C::emit(ctx, &expr3_0);
4890     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4891     return Some(expr5_0);
4892 }
4893 
4894 // Generated as internal constructor for term x64_pcmpeq.
4895 pub fn constructor_x64_pcmpeq<C: Context>(
4896     ctx: &mut C,
4897     arg0: Type,
4898     arg1: Xmm,
4899     arg2: &XmmMem,
4900 ) -> Option<Xmm> {
4901     let pattern0_0 = arg0;
4902     if pattern0_0 == I8X16 {
4903         let pattern2_0 = arg1;
4904         let pattern3_0 = arg2;
4905         // Rule at src/isa/x64/inst.isle line 2674.
4906         let expr0_0 = constructor_x64_pcmpeqb(ctx, pattern2_0, pattern3_0)?;
4907         return Some(expr0_0);
4908     }
4909     if pattern0_0 == I16X8 {
4910         let pattern2_0 = arg1;
4911         let pattern3_0 = arg2;
4912         // Rule at src/isa/x64/inst.isle line 2675.
4913         let expr0_0 = constructor_x64_pcmpeqw(ctx, pattern2_0, pattern3_0)?;
4914         return Some(expr0_0);
4915     }
4916     if pattern0_0 == I32X4 {
4917         let pattern2_0 = arg1;
4918         let pattern3_0 = arg2;
4919         // Rule at src/isa/x64/inst.isle line 2676.
4920         let expr0_0 = constructor_x64_pcmpeqd(ctx, pattern2_0, pattern3_0)?;
4921         return Some(expr0_0);
4922     }
4923     if pattern0_0 == I64X2 {
4924         let pattern2_0 = arg1;
4925         let pattern3_0 = arg2;
4926         // Rule at src/isa/x64/inst.isle line 2677.
4927         let expr0_0 = constructor_x64_pcmpeqq(ctx, pattern2_0, pattern3_0)?;
4928         return Some(expr0_0);
4929     }
4930     return None;
4931 }
4932 
4933 // Generated as internal constructor for term x64_pcmpeqb.
4934 pub fn constructor_x64_pcmpeqb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4935     let pattern0_0 = arg0;
4936     let pattern1_0 = arg1;
4937     // Rule at src/isa/x64/inst.isle line 2680.
4938     let expr0_0: Type = I8X16;
4939     let expr1_0 = SseOpcode::Pcmpeqb;
4940     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4941     return Some(expr2_0);
4942 }
4943 
4944 // Generated as internal constructor for term x64_pcmpeqw.
4945 pub fn constructor_x64_pcmpeqw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4946     let pattern0_0 = arg0;
4947     let pattern1_0 = arg1;
4948     // Rule at src/isa/x64/inst.isle line 2682.
4949     let expr0_0: Type = I16X8;
4950     let expr1_0 = SseOpcode::Pcmpeqw;
4951     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4952     return Some(expr2_0);
4953 }
4954 
4955 // Generated as internal constructor for term x64_pcmpeqd.
4956 pub fn constructor_x64_pcmpeqd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4957     let pattern0_0 = arg0;
4958     let pattern1_0 = arg1;
4959     // Rule at src/isa/x64/inst.isle line 2684.
4960     let expr0_0: Type = I32X4;
4961     let expr1_0 = SseOpcode::Pcmpeqd;
4962     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4963     return Some(expr2_0);
4964 }
4965 
4966 // Generated as internal constructor for term x64_pcmpeqq.
4967 pub fn constructor_x64_pcmpeqq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4968     let pattern0_0 = arg0;
4969     let pattern1_0 = arg1;
4970     // Rule at src/isa/x64/inst.isle line 2686.
4971     let expr0_0: Type = I64X2;
4972     let expr1_0 = SseOpcode::Pcmpeqq;
4973     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4974     return Some(expr2_0);
4975 }
4976 
4977 // Generated as internal constructor for term x64_pcmpgt.
4978 pub fn constructor_x64_pcmpgt<C: Context>(
4979     ctx: &mut C,
4980     arg0: Type,
4981     arg1: Xmm,
4982     arg2: &XmmMem,
4983 ) -> Option<Xmm> {
4984     let pattern0_0 = arg0;
4985     if pattern0_0 == I8X16 {
4986         let pattern2_0 = arg1;
4987         let pattern3_0 = arg2;
4988         // Rule at src/isa/x64/inst.isle line 2690.
4989         let expr0_0 = constructor_x64_pcmpgtb(ctx, pattern2_0, pattern3_0)?;
4990         return Some(expr0_0);
4991     }
4992     if pattern0_0 == I16X8 {
4993         let pattern2_0 = arg1;
4994         let pattern3_0 = arg2;
4995         // Rule at src/isa/x64/inst.isle line 2691.
4996         let expr0_0 = constructor_x64_pcmpgtw(ctx, pattern2_0, pattern3_0)?;
4997         return Some(expr0_0);
4998     }
4999     if pattern0_0 == I32X4 {
5000         let pattern2_0 = arg1;
5001         let pattern3_0 = arg2;
5002         // Rule at src/isa/x64/inst.isle line 2692.
5003         let expr0_0 = constructor_x64_pcmpgtd(ctx, pattern2_0, pattern3_0)?;
5004         return Some(expr0_0);
5005     }
5006     if pattern0_0 == I64X2 {
5007         let pattern2_0 = arg1;
5008         let pattern3_0 = arg2;
5009         // Rule at src/isa/x64/inst.isle line 2693.
5010         let expr0_0 = constructor_x64_pcmpgtq(ctx, pattern2_0, pattern3_0)?;
5011         return Some(expr0_0);
5012     }
5013     return None;
5014 }
5015 
5016 // Generated as internal constructor for term x64_pcmpgtb.
5017 pub fn constructor_x64_pcmpgtb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5018     let pattern0_0 = arg0;
5019     let pattern1_0 = arg1;
5020     // Rule at src/isa/x64/inst.isle line 2696.
5021     let expr0_0: Type = I8X16;
5022     let expr1_0 = SseOpcode::Pcmpgtb;
5023     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5024     return Some(expr2_0);
5025 }
5026 
5027 // Generated as internal constructor for term x64_pcmpgtw.
5028 pub fn constructor_x64_pcmpgtw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5029     let pattern0_0 = arg0;
5030     let pattern1_0 = arg1;
5031     // Rule at src/isa/x64/inst.isle line 2698.
5032     let expr0_0: Type = I16X8;
5033     let expr1_0 = SseOpcode::Pcmpgtw;
5034     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5035     return Some(expr2_0);
5036 }
5037 
5038 // Generated as internal constructor for term x64_pcmpgtd.
5039 pub fn constructor_x64_pcmpgtd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5040     let pattern0_0 = arg0;
5041     let pattern1_0 = arg1;
5042     // Rule at src/isa/x64/inst.isle line 2700.
5043     let expr0_0: Type = I32X4;
5044     let expr1_0 = SseOpcode::Pcmpgtd;
5045     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5046     return Some(expr2_0);
5047 }
5048 
5049 // Generated as internal constructor for term x64_pcmpgtq.
5050 pub fn constructor_x64_pcmpgtq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5051     let pattern0_0 = arg0;
5052     let pattern1_0 = arg1;
5053     // Rule at src/isa/x64/inst.isle line 2702.
5054     let expr0_0: Type = I64X2;
5055     let expr1_0 = SseOpcode::Pcmpgtq;
5056     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5057     return Some(expr2_0);
5058 }
5059 
5060 // Generated as internal constructor for term alu_rm.
5061 pub fn constructor_alu_rm<C: Context>(
5062     ctx: &mut C,
5063     arg0: Type,
5064     arg1: &AluRmiROpcode,
5065     arg2: &Amode,
5066     arg3: Gpr,
5067 ) -> Option<SideEffectNoResult> {
5068     let pattern0_0 = arg0;
5069     let pattern1_0 = arg1;
5070     let pattern2_0 = arg2;
5071     let pattern3_0 = arg3;
5072     // Rule at src/isa/x64/inst.isle line 2706.
5073     let expr0_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
5074     let expr1_0 = C::amode_to_synthetic_amode(ctx, pattern2_0);
5075     let expr2_0 = MInst::AluRM {
5076         size: expr0_0,
5077         op: pattern1_0.clone(),
5078         src1_dst: expr1_0,
5079         src2: pattern3_0,
5080     };
5081     let expr3_0 = SideEffectNoResult::Inst { inst: expr2_0 };
5082     return Some(expr3_0);
5083 }
5084 
5085 // Generated as internal constructor for term x64_add_mem.
5086 pub fn constructor_x64_add_mem<C: Context>(
5087     ctx: &mut C,
5088     arg0: Type,
5089     arg1: &Amode,
5090     arg2: Gpr,
5091 ) -> Option<SideEffectNoResult> {
5092     let pattern0_0 = arg0;
5093     let pattern1_0 = arg1;
5094     let pattern2_0 = arg2;
5095     // Rule at src/isa/x64/inst.isle line 2711.
5096     let expr0_0 = AluRmiROpcode::Add;
5097     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5098     return Some(expr1_0);
5099 }
5100 
5101 // Generated as internal constructor for term x64_sub_mem.
5102 pub fn constructor_x64_sub_mem<C: Context>(
5103     ctx: &mut C,
5104     arg0: Type,
5105     arg1: &Amode,
5106     arg2: Gpr,
5107 ) -> Option<SideEffectNoResult> {
5108     let pattern0_0 = arg0;
5109     let pattern1_0 = arg1;
5110     let pattern2_0 = arg2;
5111     // Rule at src/isa/x64/inst.isle line 2715.
5112     let expr0_0 = AluRmiROpcode::Sub;
5113     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5114     return Some(expr1_0);
5115 }
5116 
5117 // Generated as internal constructor for term x64_and_mem.
5118 pub fn constructor_x64_and_mem<C: Context>(
5119     ctx: &mut C,
5120     arg0: Type,
5121     arg1: &Amode,
5122     arg2: Gpr,
5123 ) -> Option<SideEffectNoResult> {
5124     let pattern0_0 = arg0;
5125     let pattern1_0 = arg1;
5126     let pattern2_0 = arg2;
5127     // Rule at src/isa/x64/inst.isle line 2719.
5128     let expr0_0 = AluRmiROpcode::And;
5129     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5130     return Some(expr1_0);
5131 }
5132 
5133 // Generated as internal constructor for term x64_or_mem.
5134 pub fn constructor_x64_or_mem<C: Context>(
5135     ctx: &mut C,
5136     arg0: Type,
5137     arg1: &Amode,
5138     arg2: Gpr,
5139 ) -> Option<SideEffectNoResult> {
5140     let pattern0_0 = arg0;
5141     let pattern1_0 = arg1;
5142     let pattern2_0 = arg2;
5143     // Rule at src/isa/x64/inst.isle line 2723.
5144     let expr0_0 = AluRmiROpcode::Or;
5145     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5146     return Some(expr1_0);
5147 }
5148 
5149 // Generated as internal constructor for term x64_xor_mem.
5150 pub fn constructor_x64_xor_mem<C: Context>(
5151     ctx: &mut C,
5152     arg0: Type,
5153     arg1: &Amode,
5154     arg2: Gpr,
5155 ) -> Option<SideEffectNoResult> {
5156     let pattern0_0 = arg0;
5157     let pattern1_0 = arg1;
5158     let pattern2_0 = arg2;
5159     // Rule at src/isa/x64/inst.isle line 2727.
5160     let expr0_0 = AluRmiROpcode::Xor;
5161     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5162     return Some(expr1_0);
5163 }
5164 
5165 // Generated as internal constructor for term reg_to_xmm_mem.
5166 pub fn constructor_reg_to_xmm_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
5167     let pattern0_0 = arg0;
5168     // Rule at src/isa/x64/inst.isle line 2784.
5169     let expr0_0 = C::xmm_new(ctx, pattern0_0);
5170     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
5171     return Some(expr1_0);
5172 }
5173 
5174 // Generated as internal constructor for term xmm_to_reg_mem.
5175 pub fn constructor_xmm_to_reg_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
5176     let pattern0_0 = arg0;
5177     // Rule at src/isa/x64/inst.isle line 2787.
5178     let expr0_0 = C::xmm_new(ctx, pattern0_0);
5179     let expr1_0 = C::xmm_to_reg(ctx, expr0_0);
5180     let expr2_0 = RegMem::Reg { reg: expr1_0 };
5181     let expr3_0 = C::reg_mem_to_xmm_mem(ctx, &expr2_0);
5182     return Some(expr3_0);
5183 }
5184 
5185 // Generated as internal constructor for term writable_gpr_to_r_reg.
5186 pub fn constructor_writable_gpr_to_r_reg<C: Context>(
5187     ctx: &mut C,
5188     arg0: WritableGpr,
5189 ) -> Option<Reg> {
5190     let pattern0_0 = arg0;
5191     // Rule at src/isa/x64/inst.isle line 2791.
5192     let expr0_0 = C::writable_gpr_to_reg(ctx, pattern0_0);
5193     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
5194     return Some(expr1_0);
5195 }
5196 
5197 // Generated as internal constructor for term writable_gpr_to_gpr_mem.
5198 pub fn constructor_writable_gpr_to_gpr_mem<C: Context>(
5199     ctx: &mut C,
5200     arg0: WritableGpr,
5201 ) -> Option<GprMem> {
5202     let pattern0_0 = arg0;
5203     // Rule at src/isa/x64/inst.isle line 2794.
5204     let expr0_0 = C::writable_gpr_to_gpr(ctx, pattern0_0);
5205     let expr1_0 = C::gpr_to_gpr_mem(ctx, expr0_0);
5206     return Some(expr1_0);
5207 }
5208 
5209 // Generated as internal constructor for term writable_gpr_to_value_regs.
5210 pub fn constructor_writable_gpr_to_value_regs<C: Context>(
5211     ctx: &mut C,
5212     arg0: WritableGpr,
5213 ) -> Option<ValueRegs> {
5214     let pattern0_0 = arg0;
5215     // Rule at src/isa/x64/inst.isle line 2797.
5216     let expr0_0 = constructor_writable_gpr_to_r_reg(ctx, pattern0_0)?;
5217     let expr1_0 = C::value_reg(ctx, expr0_0);
5218     return Some(expr1_0);
5219 }
5220 
5221 // Generated as internal constructor for term writable_xmm_to_r_reg.
5222 pub fn constructor_writable_xmm_to_r_reg<C: Context>(
5223     ctx: &mut C,
5224     arg0: WritableXmm,
5225 ) -> Option<Reg> {
5226     let pattern0_0 = arg0;
5227     // Rule at src/isa/x64/inst.isle line 2800.
5228     let expr0_0 = C::writable_xmm_to_reg(ctx, pattern0_0);
5229     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
5230     return Some(expr1_0);
5231 }
5232 
5233 // Generated as internal constructor for term writable_xmm_to_xmm_mem.
5234 pub fn constructor_writable_xmm_to_xmm_mem<C: Context>(
5235     ctx: &mut C,
5236     arg0: WritableXmm,
5237 ) -> Option<XmmMem> {
5238     let pattern0_0 = arg0;
5239     // Rule at src/isa/x64/inst.isle line 2803.
5240     let expr0_0 = C::writable_xmm_to_xmm(ctx, pattern0_0);
5241     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
5242     return Some(expr1_0);
5243 }
5244 
5245 // Generated as internal constructor for term writable_xmm_to_value_regs.
5246 pub fn constructor_writable_xmm_to_value_regs<C: Context>(
5247     ctx: &mut C,
5248     arg0: WritableXmm,
5249 ) -> Option<ValueRegs> {
5250     let pattern0_0 = arg0;
5251     // Rule at src/isa/x64/inst.isle line 2806.
5252     let expr0_0 = constructor_writable_xmm_to_r_reg(ctx, pattern0_0)?;
5253     let expr1_0 = C::value_reg(ctx, expr0_0);
5254     return Some(expr1_0);
5255 }
5256 
5257 // Generated as internal constructor for term synthetic_amode_to_gpr_mem.
5258 pub fn constructor_synthetic_amode_to_gpr_mem<C: Context>(
5259     ctx: &mut C,
5260     arg0: &SyntheticAmode,
5261 ) -> Option<GprMem> {
5262     let pattern0_0 = arg0;
5263     // Rule at src/isa/x64/inst.isle line 2813.
5264     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5265     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
5266     return Some(expr1_0);
5267 }
5268 
5269 // Generated as internal constructor for term amode_to_gpr_mem.
5270 pub fn constructor_amode_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<GprMem> {
5271     let pattern0_0 = arg0;
5272     // Rule at src/isa/x64/inst.isle line 2811.
5273     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5274     let expr1_0 = constructor_synthetic_amode_to_gpr_mem(ctx, &expr0_0)?;
5275     return Some(expr1_0);
5276 }
5277 
5278 // Generated as internal constructor for term amode_to_xmm_mem.
5279 pub fn constructor_amode_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<XmmMem> {
5280     let pattern0_0 = arg0;
5281     // Rule at src/isa/x64/inst.isle line 2816.
5282     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5283     let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, &expr0_0)?;
5284     return Some(expr1_0);
5285 }
5286 
5287 // Generated as internal constructor for term synthetic_amode_to_xmm_mem.
5288 pub fn constructor_synthetic_amode_to_xmm_mem<C: Context>(
5289     ctx: &mut C,
5290     arg0: &SyntheticAmode,
5291 ) -> Option<XmmMem> {
5292     let pattern0_0 = arg0;
5293     // Rule at src/isa/x64/inst.isle line 2819.
5294     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5295     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
5296     return Some(expr1_0);
5297 }
5298 
5299 // Generated as internal constructor for term lower.
5300 pub fn constructor_lower<C: Context>(ctx: &mut C, arg0: Inst) -> Option<InstOutput> {
5301     let pattern0_0 = arg0;
5302     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
5303         let pattern2_0 = C::value_type(ctx, pattern1_0);
5304         if pattern2_0 == I128 {
5305             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5306                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5307                 if let &InstructionData::Unary {
5308                     opcode: ref pattern6_0,
5309                     arg: pattern6_1,
5310                 } = &pattern5_0
5311                 {
5312                     if let &Opcode::Popcnt = pattern6_0 {
5313                         // Rule at src/isa/x64/lower.isle line 1876.
5314                         let expr0_0: Type = I64;
5315                         let expr1_0 = C::put_in_regs(ctx, pattern6_1);
5316                         let expr2_0: usize = 0;
5317                         let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
5318                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5319                         let expr5_0: Type = I64;
5320                         let expr6_0 = C::put_in_regs(ctx, pattern6_1);
5321                         let expr7_0: usize = 1;
5322                         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5323                         let expr9_0 = constructor_x64_popcnt(ctx, expr5_0, expr8_0)?;
5324                         let expr10_0: Type = I64;
5325                         let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
5326                         let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
5327                         let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
5328                         let expr14_0: Type = I64;
5329                         let expr15_0: u64 = 0;
5330                         let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
5331                         let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
5332                         let expr18_0 = C::output(ctx, expr17_0);
5333                         return Some(expr18_0);
5334                     }
5335                 }
5336             }
5337         }
5338         if pattern2_0 == I8X16 {
5339             if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
5340                 if let Some(()) = C::avx512bitalg_enabled(ctx, pattern2_0) {
5341                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
5342                     if let &InstructionData::Unary {
5343                         opcode: ref pattern7_0,
5344                         arg: pattern7_1,
5345                     } = &pattern6_0
5346                     {
5347                         if let &Opcode::Popcnt = pattern7_0 {
5348                             // Rule at src/isa/x64/lower.isle line 1968.
5349                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
5350                             let expr1_0 = constructor_x64_vpopcntb(ctx, &expr0_0)?;
5351                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
5352                             return Some(expr2_0);
5353                         }
5354                     }
5355                 }
5356             }
5357         }
5358         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
5359             if let Some(()) = C::use_lzcnt(ctx, pattern2_0) {
5360                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5361                 if let &InstructionData::Unary {
5362                     opcode: ref pattern6_0,
5363                     arg: pattern6_1,
5364                 } = &pattern5_0
5365                 {
5366                     if let &Opcode::Clz = pattern6_0 {
5367                         // Rule at src/isa/x64/lower.isle line 1784.
5368                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5369                         let expr1_0 = constructor_x64_lzcnt(ctx, pattern3_0, expr0_0)?;
5370                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5371                         return Some(expr2_0);
5372                     }
5373                 }
5374             }
5375             if let Some(()) = C::use_bmi1(ctx, pattern2_0) {
5376                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5377                 if let &InstructionData::Unary {
5378                     opcode: ref pattern6_0,
5379                     arg: pattern6_1,
5380                 } = &pattern5_0
5381                 {
5382                     if let &Opcode::Ctz = pattern6_0 {
5383                         // Rule at src/isa/x64/lower.isle line 1826.
5384                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5385                         let expr1_0 = constructor_x64_tzcnt(ctx, pattern3_0, expr0_0)?;
5386                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5387                         return Some(expr2_0);
5388                     }
5389                 }
5390             }
5391             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5392                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5393                 if let &InstructionData::Unary {
5394                     opcode: ref pattern6_0,
5395                     arg: pattern6_1,
5396                 } = &pattern5_0
5397                 {
5398                     if let &Opcode::Popcnt = pattern6_0 {
5399                         // Rule at src/isa/x64/lower.isle line 1862.
5400                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5401                         let expr1_0 = constructor_x64_popcnt(ctx, pattern3_0, expr0_0)?;
5402                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5403                         return Some(expr2_0);
5404                     }
5405                 }
5406             }
5407         }
5408         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
5409             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5410                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5411                 if let &InstructionData::Unary {
5412                     opcode: ref pattern6_0,
5413                     arg: pattern6_1,
5414                 } = &pattern5_0
5415                 {
5416                     if let &Opcode::Popcnt = pattern6_0 {
5417                         // Rule at src/isa/x64/lower.isle line 1869.
5418                         let expr0_0: Type = I32;
5419                         let expr1_0: Type = I32;
5420                         let expr2_0 = ExtendKind::Zero;
5421                         let expr3_0 =
5422                             constructor_extend_to_gpr(ctx, pattern6_1, expr1_0, &expr2_0)?;
5423                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5424                         let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
5425                         return Some(expr5_0);
5426                     }
5427                 }
5428             }
5429         }
5430     }
5431     let pattern0_0 = arg0;
5432     let pattern1_0 = C::inst_data(ctx, pattern0_0);
5433     match &pattern1_0 {
5434         &InstructionData::NullAry {
5435             opcode: ref pattern2_0,
5436         } => {
5437             if let &Opcode::Debugtrap = pattern2_0 {
5438                 // Rule at src/isa/x64/lower.isle line 2254.
5439                 let expr0_0 = constructor_x64_hlt(ctx)?;
5440                 let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5441                 return Some(expr1_0);
5442             }
5443         }
5444         &InstructionData::UnaryIeee32 {
5445             opcode: ref pattern2_0,
5446             imm: pattern2_1,
5447         } => {
5448             if let &Opcode::F32const = pattern2_0 {
5449                 let pattern4_0 = C::u64_from_ieee32(ctx, pattern2_1);
5450                 // Rule at src/isa/x64/lower.isle line 46.
5451                 let expr0_0: Type = F32;
5452                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5453                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5454                 return Some(expr2_0);
5455             }
5456         }
5457         &InstructionData::UnaryIeee64 {
5458             opcode: ref pattern2_0,
5459             imm: pattern2_1,
5460         } => {
5461             if let &Opcode::F64const = pattern2_0 {
5462                 let pattern4_0 = C::u64_from_ieee64(ctx, pattern2_1);
5463                 // Rule at src/isa/x64/lower.isle line 51.
5464                 let expr0_0: Type = F64;
5465                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5466                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5467                 return Some(expr2_0);
5468             }
5469         }
5470         &InstructionData::Trap {
5471             opcode: ref pattern2_0,
5472             code: ref pattern2_1,
5473         } => {
5474             match pattern2_0 {
5475                 &Opcode::Trap => {
5476                     // Rule at src/isa/x64/lower.isle line 1438.
5477                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5478                     let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5479                     return Some(expr1_0);
5480                 }
5481                 &Opcode::ResumableTrap => {
5482                     // Rule at src/isa/x64/lower.isle line 1443.
5483                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5484                     let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5485                     return Some(expr1_0);
5486                 }
5487                 _ => {}
5488             }
5489         }
5490         &InstructionData::Store {
5491             opcode: ref pattern2_0,
5492             args: ref pattern2_1,
5493             flags: pattern2_2,
5494             offset: pattern2_3,
5495         } => {
5496             match pattern2_0 {
5497                 &Opcode::Store => {
5498                     let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5499                     if let Some(pattern5_0) = C::def_inst(ctx, pattern4_0) {
5500                         if let Some(pattern6_0) = C::first_result(ctx, pattern5_0) {
5501                             let pattern7_0 = C::value_type(ctx, pattern6_0);
5502                             if let Some(pattern8_0) = C::ty_32_or_64(ctx, pattern7_0) {
5503                                 let pattern9_0 = C::inst_data(ctx, pattern5_0);
5504                                 if let &InstructionData::Binary {
5505                                     opcode: ref pattern10_0,
5506                                     args: ref pattern10_1,
5507                                 } = &pattern9_0
5508                                 {
5509                                     match pattern10_0 {
5510                                         &Opcode::Iadd => {
5511                                             let (pattern12_0, pattern12_1) =
5512                                                 C::unpack_value_array_2(ctx, pattern10_1);
5513                                             if let Some(pattern13_0) =
5514                                                 C::sinkable_load(ctx, pattern12_0)
5515                                             {
5516                                                 if let Some(pattern14_0) =
5517                                                     C::def_inst(ctx, pattern12_0)
5518                                                 {
5519                                                     let pattern15_0 =
5520                                                         C::inst_data(ctx, pattern14_0);
5521                                                     if let &InstructionData::Load {
5522                                                         opcode: ref pattern16_0,
5523                                                         arg: pattern16_1,
5524                                                         flags: pattern16_2,
5525                                                         offset: pattern16_3,
5526                                                     } = &pattern15_0
5527                                                     {
5528                                                         if let &Opcode::Load = pattern16_0 {
5529                                                             if pattern4_1 == pattern16_1 {
5530                                                                 if pattern2_2 == pattern16_2 {
5531                                                                     if pattern2_3 == pattern16_3 {
5532                                                                         // Rule at src/isa/x64/lower.isle line 2662.
5533                                                                         let expr0_0 = C::sink_load(
5534                                                                             ctx,
5535                                                                             &pattern13_0,
5536                                                                         );
5537                                                                         let expr1_0 =
5538                                                                             constructor_to_amode(
5539                                                                                 ctx,
5540                                                                                 pattern16_2,
5541                                                                                 pattern16_1,
5542                                                                                 pattern16_3,
5543                                                                             )?;
5544                                                                         let expr2_0 =
5545                                                                             constructor_put_in_gpr(
5546                                                                                 ctx,
5547                                                                                 pattern12_1,
5548                                                                             )?;
5549                                                                         let expr3_0 = constructor_x64_add_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5550                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5551                                                                         return Some(expr4_0);
5552                                                                     }
5553                                                                 }
5554                                                             }
5555                                                         }
5556                                                     }
5557                                                 }
5558                                             }
5559                                             if let Some(pattern13_0) =
5560                                                 C::sinkable_load(ctx, pattern12_1)
5561                                             {
5562                                                 if let Some(pattern14_0) =
5563                                                     C::def_inst(ctx, pattern12_1)
5564                                                 {
5565                                                     let pattern15_0 =
5566                                                         C::inst_data(ctx, pattern14_0);
5567                                                     if let &InstructionData::Load {
5568                                                         opcode: ref pattern16_0,
5569                                                         arg: pattern16_1,
5570                                                         flags: pattern16_2,
5571                                                         offset: pattern16_3,
5572                                                     } = &pattern15_0
5573                                                     {
5574                                                         if let &Opcode::Load = pattern16_0 {
5575                                                             if pattern4_1 == pattern16_1 {
5576                                                                 if pattern2_2 == pattern16_2 {
5577                                                                     if pattern2_3 == pattern16_3 {
5578                                                                         // Rule at src/isa/x64/lower.isle line 2676.
5579                                                                         let expr0_0 = C::sink_load(
5580                                                                             ctx,
5581                                                                             &pattern13_0,
5582                                                                         );
5583                                                                         let expr1_0 =
5584                                                                             constructor_to_amode(
5585                                                                                 ctx,
5586                                                                                 pattern16_2,
5587                                                                                 pattern16_1,
5588                                                                                 pattern16_3,
5589                                                                             )?;
5590                                                                         let expr2_0 =
5591                                                                             constructor_put_in_gpr(
5592                                                                                 ctx,
5593                                                                                 pattern12_0,
5594                                                                             )?;
5595                                                                         let expr3_0 = constructor_x64_add_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5596                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5597                                                                         return Some(expr4_0);
5598                                                                     }
5599                                                                 }
5600                                                             }
5601                                                         }
5602                                                     }
5603                                                 }
5604                                             }
5605                                         }
5606                                         &Opcode::Isub => {
5607                                             let (pattern12_0, pattern12_1) =
5608                                                 C::unpack_value_array_2(ctx, pattern10_1);
5609                                             if let Some(pattern13_0) =
5610                                                 C::sinkable_load(ctx, pattern12_0)
5611                                             {
5612                                                 if let Some(pattern14_0) =
5613                                                     C::def_inst(ctx, pattern12_0)
5614                                                 {
5615                                                     let pattern15_0 =
5616                                                         C::inst_data(ctx, pattern14_0);
5617                                                     if let &InstructionData::Load {
5618                                                         opcode: ref pattern16_0,
5619                                                         arg: pattern16_1,
5620                                                         flags: pattern16_2,
5621                                                         offset: pattern16_3,
5622                                                     } = &pattern15_0
5623                                                     {
5624                                                         if let &Opcode::Load = pattern16_0 {
5625                                                             if pattern4_1 == pattern16_1 {
5626                                                                 if pattern2_2 == pattern16_2 {
5627                                                                     if pattern2_3 == pattern16_3 {
5628                                                                         // Rule at src/isa/x64/lower.isle line 2690.
5629                                                                         let expr0_0 = C::sink_load(
5630                                                                             ctx,
5631                                                                             &pattern13_0,
5632                                                                         );
5633                                                                         let expr1_0 =
5634                                                                             constructor_to_amode(
5635                                                                                 ctx,
5636                                                                                 pattern16_2,
5637                                                                                 pattern16_1,
5638                                                                                 pattern16_3,
5639                                                                             )?;
5640                                                                         let expr2_0 =
5641                                                                             constructor_put_in_gpr(
5642                                                                                 ctx,
5643                                                                                 pattern12_1,
5644                                                                             )?;
5645                                                                         let expr3_0 = constructor_x64_sub_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5646                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5647                                                                         return Some(expr4_0);
5648                                                                     }
5649                                                                 }
5650                                                             }
5651                                                         }
5652                                                     }
5653                                                 }
5654                                             }
5655                                         }
5656                                         &Opcode::Band => {
5657                                             let (pattern12_0, pattern12_1) =
5658                                                 C::unpack_value_array_2(ctx, pattern10_1);
5659                                             if let Some(pattern13_0) =
5660                                                 C::sinkable_load(ctx, pattern12_0)
5661                                             {
5662                                                 if let Some(pattern14_0) =
5663                                                     C::def_inst(ctx, pattern12_0)
5664                                                 {
5665                                                     let pattern15_0 =
5666                                                         C::inst_data(ctx, pattern14_0);
5667                                                     if let &InstructionData::Load {
5668                                                         opcode: ref pattern16_0,
5669                                                         arg: pattern16_1,
5670                                                         flags: pattern16_2,
5671                                                         offset: pattern16_3,
5672                                                     } = &pattern15_0
5673                                                     {
5674                                                         if let &Opcode::Load = pattern16_0 {
5675                                                             if pattern4_1 == pattern16_1 {
5676                                                                 if pattern2_2 == pattern16_2 {
5677                                                                     if pattern2_3 == pattern16_3 {
5678                                                                         // Rule at src/isa/x64/lower.isle line 2704.
5679                                                                         let expr0_0 = C::sink_load(
5680                                                                             ctx,
5681                                                                             &pattern13_0,
5682                                                                         );
5683                                                                         let expr1_0 =
5684                                                                             constructor_to_amode(
5685                                                                                 ctx,
5686                                                                                 pattern16_2,
5687                                                                                 pattern16_1,
5688                                                                                 pattern16_3,
5689                                                                             )?;
5690                                                                         let expr2_0 =
5691                                                                             constructor_put_in_gpr(
5692                                                                                 ctx,
5693                                                                                 pattern12_1,
5694                                                                             )?;
5695                                                                         let expr3_0 = constructor_x64_and_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5696                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5697                                                                         return Some(expr4_0);
5698                                                                     }
5699                                                                 }
5700                                                             }
5701                                                         }
5702                                                     }
5703                                                 }
5704                                             }
5705                                             if let Some(pattern13_0) =
5706                                                 C::sinkable_load(ctx, pattern12_1)
5707                                             {
5708                                                 if let Some(pattern14_0) =
5709                                                     C::def_inst(ctx, pattern12_1)
5710                                                 {
5711                                                     let pattern15_0 =
5712                                                         C::inst_data(ctx, pattern14_0);
5713                                                     if let &InstructionData::Load {
5714                                                         opcode: ref pattern16_0,
5715                                                         arg: pattern16_1,
5716                                                         flags: pattern16_2,
5717                                                         offset: pattern16_3,
5718                                                     } = &pattern15_0
5719                                                     {
5720                                                         if let &Opcode::Load = pattern16_0 {
5721                                                             if pattern4_1 == pattern16_1 {
5722                                                                 if pattern2_2 == pattern16_2 {
5723                                                                     if pattern2_3 == pattern16_3 {
5724                                                                         // Rule at src/isa/x64/lower.isle line 2718.
5725                                                                         let expr0_0 = C::sink_load(
5726                                                                             ctx,
5727                                                                             &pattern13_0,
5728                                                                         );
5729                                                                         let expr1_0 =
5730                                                                             constructor_to_amode(
5731                                                                                 ctx,
5732                                                                                 pattern16_2,
5733                                                                                 pattern16_1,
5734                                                                                 pattern16_3,
5735                                                                             )?;
5736                                                                         let expr2_0 =
5737                                                                             constructor_put_in_gpr(
5738                                                                                 ctx,
5739                                                                                 pattern12_0,
5740                                                                             )?;
5741                                                                         let expr3_0 = constructor_x64_and_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5742                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5743                                                                         return Some(expr4_0);
5744                                                                     }
5745                                                                 }
5746                                                             }
5747                                                         }
5748                                                     }
5749                                                 }
5750                                             }
5751                                         }
5752                                         &Opcode::Bor => {
5753                                             let (pattern12_0, pattern12_1) =
5754                                                 C::unpack_value_array_2(ctx, pattern10_1);
5755                                             if let Some(pattern13_0) =
5756                                                 C::sinkable_load(ctx, pattern12_0)
5757                                             {
5758                                                 if let Some(pattern14_0) =
5759                                                     C::def_inst(ctx, pattern12_0)
5760                                                 {
5761                                                     let pattern15_0 =
5762                                                         C::inst_data(ctx, pattern14_0);
5763                                                     if let &InstructionData::Load {
5764                                                         opcode: ref pattern16_0,
5765                                                         arg: pattern16_1,
5766                                                         flags: pattern16_2,
5767                                                         offset: pattern16_3,
5768                                                     } = &pattern15_0
5769                                                     {
5770                                                         if let &Opcode::Load = pattern16_0 {
5771                                                             if pattern4_1 == pattern16_1 {
5772                                                                 if pattern2_2 == pattern16_2 {
5773                                                                     if pattern2_3 == pattern16_3 {
5774                                                                         // Rule at src/isa/x64/lower.isle line 2732.
5775                                                                         let expr0_0 = C::sink_load(
5776                                                                             ctx,
5777                                                                             &pattern13_0,
5778                                                                         );
5779                                                                         let expr1_0 =
5780                                                                             constructor_to_amode(
5781                                                                                 ctx,
5782                                                                                 pattern16_2,
5783                                                                                 pattern16_1,
5784                                                                                 pattern16_3,
5785                                                                             )?;
5786                                                                         let expr2_0 =
5787                                                                             constructor_put_in_gpr(
5788                                                                                 ctx,
5789                                                                                 pattern12_1,
5790                                                                             )?;
5791                                                                         let expr3_0 =
5792                                                                             constructor_x64_or_mem(
5793                                                                                 ctx, pattern8_0,
5794                                                                                 &expr1_0, expr2_0,
5795                                                                             )?;
5796                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5797                                                                         return Some(expr4_0);
5798                                                                     }
5799                                                                 }
5800                                                             }
5801                                                         }
5802                                                     }
5803                                                 }
5804                                             }
5805                                             if let Some(pattern13_0) =
5806                                                 C::sinkable_load(ctx, pattern12_1)
5807                                             {
5808                                                 if let Some(pattern14_0) =
5809                                                     C::def_inst(ctx, pattern12_1)
5810                                                 {
5811                                                     let pattern15_0 =
5812                                                         C::inst_data(ctx, pattern14_0);
5813                                                     if let &InstructionData::Load {
5814                                                         opcode: ref pattern16_0,
5815                                                         arg: pattern16_1,
5816                                                         flags: pattern16_2,
5817                                                         offset: pattern16_3,
5818                                                     } = &pattern15_0
5819                                                     {
5820                                                         if let &Opcode::Load = pattern16_0 {
5821                                                             if pattern4_1 == pattern16_1 {
5822                                                                 if pattern2_2 == pattern16_2 {
5823                                                                     if pattern2_3 == pattern16_3 {
5824                                                                         // Rule at src/isa/x64/lower.isle line 2746.
5825                                                                         let expr0_0 = C::sink_load(
5826                                                                             ctx,
5827                                                                             &pattern13_0,
5828                                                                         );
5829                                                                         let expr1_0 =
5830                                                                             constructor_to_amode(
5831                                                                                 ctx,
5832                                                                                 pattern16_2,
5833                                                                                 pattern16_1,
5834                                                                                 pattern16_3,
5835                                                                             )?;
5836                                                                         let expr2_0 =
5837                                                                             constructor_put_in_gpr(
5838                                                                                 ctx,
5839                                                                                 pattern12_0,
5840                                                                             )?;
5841                                                                         let expr3_0 =
5842                                                                             constructor_x64_or_mem(
5843                                                                                 ctx, pattern8_0,
5844                                                                                 &expr1_0, expr2_0,
5845                                                                             )?;
5846                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5847                                                                         return Some(expr4_0);
5848                                                                     }
5849                                                                 }
5850                                                             }
5851                                                         }
5852                                                     }
5853                                                 }
5854                                             }
5855                                         }
5856                                         &Opcode::Bxor => {
5857                                             let (pattern12_0, pattern12_1) =
5858                                                 C::unpack_value_array_2(ctx, pattern10_1);
5859                                             if let Some(pattern13_0) =
5860                                                 C::sinkable_load(ctx, pattern12_0)
5861                                             {
5862                                                 if let Some(pattern14_0) =
5863                                                     C::def_inst(ctx, pattern12_0)
5864                                                 {
5865                                                     let pattern15_0 =
5866                                                         C::inst_data(ctx, pattern14_0);
5867                                                     if let &InstructionData::Load {
5868                                                         opcode: ref pattern16_0,
5869                                                         arg: pattern16_1,
5870                                                         flags: pattern16_2,
5871                                                         offset: pattern16_3,
5872                                                     } = &pattern15_0
5873                                                     {
5874                                                         if let &Opcode::Load = pattern16_0 {
5875                                                             if pattern4_1 == pattern16_1 {
5876                                                                 if pattern2_2 == pattern16_2 {
5877                                                                     if pattern2_3 == pattern16_3 {
5878                                                                         // Rule at src/isa/x64/lower.isle line 2760.
5879                                                                         let expr0_0 = C::sink_load(
5880                                                                             ctx,
5881                                                                             &pattern13_0,
5882                                                                         );
5883                                                                         let expr1_0 =
5884                                                                             constructor_to_amode(
5885                                                                                 ctx,
5886                                                                                 pattern16_2,
5887                                                                                 pattern16_1,
5888                                                                                 pattern16_3,
5889                                                                             )?;
5890                                                                         let expr2_0 =
5891                                                                             constructor_put_in_gpr(
5892                                                                                 ctx,
5893                                                                                 pattern12_1,
5894                                                                             )?;
5895                                                                         let expr3_0 = constructor_x64_xor_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5896                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5897                                                                         return Some(expr4_0);
5898                                                                     }
5899                                                                 }
5900                                                             }
5901                                                         }
5902                                                     }
5903                                                 }
5904                                             }
5905                                             if let Some(pattern13_0) =
5906                                                 C::sinkable_load(ctx, pattern12_1)
5907                                             {
5908                                                 if let Some(pattern14_0) =
5909                                                     C::def_inst(ctx, pattern12_1)
5910                                                 {
5911                                                     let pattern15_0 =
5912                                                         C::inst_data(ctx, pattern14_0);
5913                                                     if let &InstructionData::Load {
5914                                                         opcode: ref pattern16_0,
5915                                                         arg: pattern16_1,
5916                                                         flags: pattern16_2,
5917                                                         offset: pattern16_3,
5918                                                     } = &pattern15_0
5919                                                     {
5920                                                         if let &Opcode::Load = pattern16_0 {
5921                                                             if pattern4_1 == pattern16_1 {
5922                                                                 if pattern2_2 == pattern16_2 {
5923                                                                     if pattern2_3 == pattern16_3 {
5924                                                                         // Rule at src/isa/x64/lower.isle line 2774.
5925                                                                         let expr0_0 = C::sink_load(
5926                                                                             ctx,
5927                                                                             &pattern13_0,
5928                                                                         );
5929                                                                         let expr1_0 =
5930                                                                             constructor_to_amode(
5931                                                                                 ctx,
5932                                                                                 pattern16_2,
5933                                                                                 pattern16_1,
5934                                                                                 pattern16_3,
5935                                                                             )?;
5936                                                                         let expr2_0 =
5937                                                                             constructor_put_in_gpr(
5938                                                                                 ctx,
5939                                                                                 pattern12_0,
5940                                                                             )?;
5941                                                                         let expr3_0 = constructor_x64_xor_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5942                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5943                                                                         return Some(expr4_0);
5944                                                                     }
5945                                                                 }
5946                                                             }
5947                                                         }
5948                                                     }
5949                                                 }
5950                                             }
5951                                         }
5952                                         _ => {}
5953                                     }
5954                                 }
5955                             }
5956                         }
5957                     }
5958                     let pattern5_0 = C::value_type(ctx, pattern4_0);
5959                     if pattern5_0 == F32 {
5960                         // Rule at src/isa/x64/lower.isle line 2605.
5961                         let expr0_0 = SseOpcode::Movss;
5962                         let expr1_0 =
5963                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
5964                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
5965                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5966                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
5967                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
5968                         return Some(expr5_0);
5969                     }
5970                     if pattern5_0 == F64 {
5971                         // Rule at src/isa/x64/lower.isle line 2613.
5972                         let expr0_0 = SseOpcode::Movsd;
5973                         let expr1_0 =
5974                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
5975                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
5976                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5977                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
5978                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
5979                         return Some(expr5_0);
5980                     }
5981                     if pattern5_0 == F32X4 {
5982                         // Rule at src/isa/x64/lower.isle line 2621.
5983                         let expr0_0 = SseOpcode::Movups;
5984                         let expr1_0 =
5985                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
5986                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
5987                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5988                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
5989                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
5990                         return Some(expr5_0);
5991                     }
5992                     if pattern5_0 == F64X2 {
5993                         // Rule at src/isa/x64/lower.isle line 2629.
5994                         let expr0_0 = SseOpcode::Movupd;
5995                         let expr1_0 =
5996                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
5997                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
5998                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5999                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
6000                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6001                         return Some(expr5_0);
6002                     }
6003                     if let Some(pattern6_0) = C::ty_int_bool_128(ctx, pattern5_0) {
6004                         // Rule at src/isa/x64/lower.isle line 2645.
6005                         let expr0_0 = C::put_in_regs(ctx, pattern4_0);
6006                         let expr1_0: usize = 0;
6007                         let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6008                         let expr3_0: usize = 1;
6009                         let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6010                         let expr5_0 =
6011                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6012                         let expr6_0: u32 = 8;
6013                         let expr7_0 = C::amode_offset(ctx, &expr5_0, expr6_0);
6014                         let expr8_0: Type = I64;
6015                         let expr9_0 = C::amode_to_synthetic_amode(ctx, &expr5_0);
6016                         let expr10_0 = constructor_x64_movrm(ctx, expr8_0, &expr9_0, expr2_0)?;
6017                         let expr11_0: Type = I64;
6018                         let expr12_0 = C::amode_to_synthetic_amode(ctx, &expr7_0);
6019                         let expr13_0 = constructor_x64_movrm(ctx, expr11_0, &expr12_0, expr4_0)?;
6020                         let expr14_0 = constructor_side_effect_concat(ctx, &expr10_0, &expr13_0)?;
6021                         let expr15_0 = constructor_side_effect(ctx, &expr14_0)?;
6022                         return Some(expr15_0);
6023                     }
6024                     if let Some(pattern6_0) = C::ty_vec128_int(ctx, pattern5_0) {
6025                         // Rule at src/isa/x64/lower.isle line 2637.
6026                         let expr0_0 = SseOpcode::Movdqu;
6027                         let expr1_0 =
6028                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6029                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6030                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6031                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
6032                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6033                         return Some(expr5_0);
6034                     }
6035                     if let Some(pattern6_0) = C::is_gpr_type(ctx, pattern5_0) {
6036                         // Rule at src/isa/x64/lower.isle line 2586.
6037                         let expr0_0 =
6038                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6039                         let expr1_0 = C::amode_to_synthetic_amode(ctx, &expr0_0);
6040                         let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6041                         let expr3_0 = constructor_x64_movrm(ctx, pattern6_0, &expr1_0, expr2_0)?;
6042                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
6043                         return Some(expr4_0);
6044                     }
6045                 }
6046                 &Opcode::Istore8 => {
6047                     let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6048                     // Rule at src/isa/x64/lower.isle line 2594.
6049                     let expr0_0: Type = I8;
6050                     let expr1_0 = constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6051                     let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6052                     let expr3_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6053                     let expr4_0 = constructor_x64_movrm(ctx, expr0_0, &expr2_0, expr3_0)?;
6054                     let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6055                     return Some(expr5_0);
6056                 }
6057                 &Opcode::Istore16 => {
6058                     let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6059                     // Rule at src/isa/x64/lower.isle line 2597.
6060                     let expr0_0: Type = I16;
6061                     let expr1_0 = constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6062                     let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6063                     let expr3_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6064                     let expr4_0 = constructor_x64_movrm(ctx, expr0_0, &expr2_0, expr3_0)?;
6065                     let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6066                     return Some(expr5_0);
6067                 }
6068                 &Opcode::Istore32 => {
6069                     let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6070                     // Rule at src/isa/x64/lower.isle line 2600.
6071                     let expr0_0: Type = I32;
6072                     let expr1_0 = constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6073                     let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6074                     let expr3_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6075                     let expr4_0 = constructor_x64_movrm(ctx, expr0_0, &expr2_0, expr3_0)?;
6076                     let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6077                     return Some(expr5_0);
6078                 }
6079                 _ => {}
6080             }
6081         }
6082         &InstructionData::TernaryImm8 {
6083             opcode: ref pattern2_0,
6084             args: ref pattern2_1,
6085             imm: pattern2_2,
6086         } => {
6087             if let &Opcode::Insertlane = pattern2_0 {
6088                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6089                 let pattern5_0 = C::value_type(ctx, pattern4_0);
6090                 let pattern6_0 = C::u8_from_uimm8(ctx, pattern2_2);
6091                 // Rule at src/isa/x64/lower.isle line 1302.
6092                 let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6093                 let expr1_0 = C::put_in_reg_mem(ctx, pattern4_1);
6094                 let expr2_0 =
6095                     constructor_vec_insert_lane(ctx, pattern5_0, expr0_0, &expr1_0, pattern6_0)?;
6096                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6097                 return Some(expr3_0);
6098             }
6099         }
6100         &InstructionData::FloatCompare {
6101             opcode: ref pattern2_0,
6102             args: ref pattern2_1,
6103             cond: ref pattern2_2,
6104         } => {
6105             if let &Opcode::Fcmp = pattern2_0 {
6106                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6107                 let pattern5_0 = C::value_type(ctx, pattern4_0);
6108                 if let Some(pattern6_0) = C::ty_scalar_float(ctx, pattern5_0) {
6109                     match pattern2_2 {
6110                         &FloatCC::Equal => {
6111                             // Rule at src/isa/x64/lower.isle line 1575.
6112                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6113                             let expr1_0 = CC::NP;
6114                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6115                             let expr3_0 = CC::Z;
6116                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
6117                             let expr5_0 =
6118                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
6119                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
6120                             let expr7_0: usize = 0;
6121                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6122                             let expr9_0: usize = 1;
6123                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
6124                             let expr11_0: Type = I32;
6125                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
6126                             let expr13_0 = constructor_x64_and(ctx, expr11_0, expr8_0, &expr12_0)?;
6127                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
6128                             return Some(expr14_0);
6129                         }
6130                         &FloatCC::GreaterThan => {
6131                             // Rule at src/isa/x64/lower.isle line 1603.
6132                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6133                             let expr1_0 = CC::NBE;
6134                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6135                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6136                             let expr4_0 = C::output(ctx, expr3_0);
6137                             return Some(expr4_0);
6138                         }
6139                         &FloatCC::GreaterThanOrEqual => {
6140                             // Rule at src/isa/x64/lower.isle line 1605.
6141                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6142                             let expr1_0 = CC::NB;
6143                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6144                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6145                             let expr4_0 = C::output(ctx, expr3_0);
6146                             return Some(expr4_0);
6147                         }
6148                         &FloatCC::LessThan => {
6149                             // Rule at src/isa/x64/lower.isle line 1615.
6150                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
6151                             let expr1_0 = CC::NBE;
6152                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6153                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6154                             let expr4_0 = C::output(ctx, expr3_0);
6155                             return Some(expr4_0);
6156                         }
6157                         &FloatCC::LessThanOrEqual => {
6158                             // Rule at src/isa/x64/lower.isle line 1618.
6159                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
6160                             let expr1_0 = CC::NB;
6161                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6162                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6163                             let expr4_0 = C::output(ctx, expr3_0);
6164                             return Some(expr4_0);
6165                         }
6166                         &FloatCC::NotEqual => {
6167                             // Rule at src/isa/x64/lower.isle line 1584.
6168                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6169                             let expr1_0 = CC::P;
6170                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6171                             let expr3_0 = CC::NZ;
6172                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
6173                             let expr5_0 =
6174                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
6175                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
6176                             let expr7_0: usize = 0;
6177                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6178                             let expr9_0: usize = 1;
6179                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
6180                             let expr11_0: Type = I32;
6181                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
6182                             let expr13_0 = constructor_x64_or(ctx, expr11_0, expr8_0, &expr12_0)?;
6183                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
6184                             return Some(expr14_0);
6185                         }
6186                         &FloatCC::Ordered => {
6187                             // Rule at src/isa/x64/lower.isle line 1595.
6188                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6189                             let expr1_0 = CC::NP;
6190                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6191                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6192                             let expr4_0 = C::output(ctx, expr3_0);
6193                             return Some(expr4_0);
6194                         }
6195                         &FloatCC::OrderedNotEqual => {
6196                             // Rule at src/isa/x64/lower.isle line 1599.
6197                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6198                             let expr1_0 = CC::NZ;
6199                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6200                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6201                             let expr4_0 = C::output(ctx, expr3_0);
6202                             return Some(expr4_0);
6203                         }
6204                         &FloatCC::Unordered => {
6205                             // Rule at src/isa/x64/lower.isle line 1597.
6206                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6207                             let expr1_0 = CC::P;
6208                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6209                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6210                             let expr4_0 = C::output(ctx, expr3_0);
6211                             return Some(expr4_0);
6212                         }
6213                         &FloatCC::UnorderedOrEqual => {
6214                             // Rule at src/isa/x64/lower.isle line 1601.
6215                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6216                             let expr1_0 = CC::Z;
6217                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6218                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6219                             let expr4_0 = C::output(ctx, expr3_0);
6220                             return Some(expr4_0);
6221                         }
6222                         &FloatCC::UnorderedOrGreaterThan => {
6223                             // Rule at src/isa/x64/lower.isle line 1621.
6224                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
6225                             let expr1_0 = CC::B;
6226                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6227                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6228                             let expr4_0 = C::output(ctx, expr3_0);
6229                             return Some(expr4_0);
6230                         }
6231                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
6232                             // Rule at src/isa/x64/lower.isle line 1624.
6233                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
6234                             let expr1_0 = CC::BE;
6235                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6236                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6237                             let expr4_0 = C::output(ctx, expr3_0);
6238                             return Some(expr4_0);
6239                         }
6240                         &FloatCC::UnorderedOrLessThan => {
6241                             // Rule at src/isa/x64/lower.isle line 1607.
6242                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6243                             let expr1_0 = CC::B;
6244                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6245                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6246                             let expr4_0 = C::output(ctx, expr3_0);
6247                             return Some(expr4_0);
6248                         }
6249                         &FloatCC::UnorderedOrLessThanOrEqual => {
6250                             // Rule at src/isa/x64/lower.isle line 1609.
6251                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6252                             let expr1_0 = CC::BE;
6253                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6254                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6255                             let expr4_0 = C::output(ctx, expr3_0);
6256                             return Some(expr4_0);
6257                         }
6258                         _ => {}
6259                     }
6260                 }
6261                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
6262                     match pattern2_2 {
6263                         &FloatCC::Equal => {
6264                             // Rule at src/isa/x64/lower.isle line 1632.
6265                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6266                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6267                             let expr2_0 = FcmpImm::Equal;
6268                             let expr3_0 =
6269                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6270                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6271                             return Some(expr4_0);
6272                         }
6273                         &FloatCC::GreaterThan => {
6274                             // Rule at src/isa/x64/lower.isle line 1652.
6275                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6276                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6277                             let expr2_0 = FcmpImm::LessThan;
6278                             let expr3_0 =
6279                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6280                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6281                             return Some(expr4_0);
6282                         }
6283                         &FloatCC::GreaterThanOrEqual => {
6284                             // Rule at src/isa/x64/lower.isle line 1654.
6285                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6286                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6287                             let expr2_0 = FcmpImm::LessThanOrEqual;
6288                             let expr3_0 =
6289                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6290                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6291                             return Some(expr4_0);
6292                         }
6293                         &FloatCC::LessThan => {
6294                             // Rule at src/isa/x64/lower.isle line 1636.
6295                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6296                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6297                             let expr2_0 = FcmpImm::LessThan;
6298                             let expr3_0 =
6299                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6300                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6301                             return Some(expr4_0);
6302                         }
6303                         &FloatCC::LessThanOrEqual => {
6304                             // Rule at src/isa/x64/lower.isle line 1638.
6305                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6306                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6307                             let expr2_0 = FcmpImm::LessThanOrEqual;
6308                             let expr3_0 =
6309                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6310                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6311                             return Some(expr4_0);
6312                         }
6313                         &FloatCC::NotEqual => {
6314                             // Rule at src/isa/x64/lower.isle line 1634.
6315                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6316                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6317                             let expr2_0 = FcmpImm::NotEqual;
6318                             let expr3_0 =
6319                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6320                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6321                             return Some(expr4_0);
6322                         }
6323                         &FloatCC::Ordered => {
6324                             // Rule at src/isa/x64/lower.isle line 1640.
6325                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6326                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6327                             let expr2_0 = FcmpImm::Ordered;
6328                             let expr3_0 =
6329                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6330                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6331                             return Some(expr4_0);
6332                         }
6333                         &FloatCC::Unordered => {
6334                             // Rule at src/isa/x64/lower.isle line 1642.
6335                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6336                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6337                             let expr2_0 = FcmpImm::Unordered;
6338                             let expr3_0 =
6339                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6340                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6341                             return Some(expr4_0);
6342                         }
6343                         &FloatCC::UnorderedOrGreaterThan => {
6344                             // Rule at src/isa/x64/lower.isle line 1644.
6345                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6346                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6347                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
6348                             let expr3_0 =
6349                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6350                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6351                             return Some(expr4_0);
6352                         }
6353                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
6354                             // Rule at src/isa/x64/lower.isle line 1646.
6355                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6356                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6357                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
6358                             let expr3_0 =
6359                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6360                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6361                             return Some(expr4_0);
6362                         }
6363                         &FloatCC::UnorderedOrLessThan => {
6364                             // Rule at src/isa/x64/lower.isle line 1656.
6365                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6366                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6367                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
6368                             let expr3_0 =
6369                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6370                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6371                             return Some(expr4_0);
6372                         }
6373                         &FloatCC::UnorderedOrLessThanOrEqual => {
6374                             // Rule at src/isa/x64/lower.isle line 1658.
6375                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6376                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6377                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
6378                             let expr3_0 =
6379                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6380                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6381                             return Some(expr4_0);
6382                         }
6383                         _ => {}
6384                     }
6385                 }
6386             }
6387         }
6388         &InstructionData::IntCompare {
6389             opcode: ref pattern2_0,
6390             args: ref pattern2_1,
6391             cond: ref pattern2_2,
6392         } => {
6393             if let &Opcode::Icmp = pattern2_0 {
6394                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6395                 let pattern5_0 = C::value_type(ctx, pattern4_0);
6396                 if pattern5_0 == I128 {
6397                     match pattern2_2 {
6398                         &IntCC::Equal => {
6399                             // Rule at src/isa/x64/lower.isle line 1526.
6400                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
6401                             let expr1_0: usize = 0;
6402                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6403                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
6404                             let expr4_0: usize = 1;
6405                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
6406                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
6407                             let expr7_0: usize = 0;
6408                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6409                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
6410                             let expr10_0: usize = 1;
6411                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6412                             let expr12_0 = OperandSize::Size64;
6413                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
6414                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
6415                             let expr15_0 = CC::Z;
6416                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
6417                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
6418                             let expr18_0 = OperandSize::Size64;
6419                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
6420                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
6421                             let expr21_0 = CC::Z;
6422                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
6423                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
6424                             let expr24_0: Type = I64;
6425                             let expr25_0 = C::gpr_new(ctx, expr17_0);
6426                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
6427                             let expr27_0 = constructor_x64_and(ctx, expr24_0, expr25_0, &expr26_0)?;
6428                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
6429                             let expr29_0 = OperandSize::Size64;
6430                             let expr30_0: u32 = 1;
6431                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
6432                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
6433                             let expr33_0 = C::gpr_new(ctx, expr28_0);
6434                             let expr34_0 =
6435                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
6436                             let expr35_0 = CC::NZ;
6437                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
6438                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
6439                             let expr38_0 = C::output(ctx, expr37_0);
6440                             return Some(expr38_0);
6441                         }
6442                         &IntCC::NotEqual => {
6443                             // Rule at src/isa/x64/lower.isle line 1545.
6444                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
6445                             let expr1_0: usize = 0;
6446                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6447                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
6448                             let expr4_0: usize = 1;
6449                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
6450                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
6451                             let expr7_0: usize = 0;
6452                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6453                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
6454                             let expr10_0: usize = 1;
6455                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6456                             let expr12_0 = OperandSize::Size64;
6457                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
6458                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
6459                             let expr15_0 = CC::NZ;
6460                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
6461                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
6462                             let expr18_0 = OperandSize::Size64;
6463                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
6464                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
6465                             let expr21_0 = CC::NZ;
6466                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
6467                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
6468                             let expr24_0: Type = I64;
6469                             let expr25_0 = C::gpr_new(ctx, expr17_0);
6470                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
6471                             let expr27_0 = constructor_x64_or(ctx, expr24_0, expr25_0, &expr26_0)?;
6472                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
6473                             let expr29_0 = OperandSize::Size64;
6474                             let expr30_0: u32 = 1;
6475                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
6476                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
6477                             let expr33_0 = C::gpr_new(ctx, expr28_0);
6478                             let expr34_0 =
6479                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
6480                             let expr35_0 = CC::NZ;
6481                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
6482                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
6483                             let expr38_0 = C::output(ctx, expr37_0);
6484                             return Some(expr38_0);
6485                         }
6486                         _ => {}
6487                     }
6488                 }
6489                 if pattern5_0 == I64X2 {
6490                     match pattern2_2 {
6491                         &IntCC::SignedGreaterThanOrEqual => {
6492                             // Rule at src/isa/x64/lower.isle line 1511.
6493                             let expr0_0: Type = I64X2;
6494                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6495                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6496                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
6497                             let expr4_0: Type = I64X2;
6498                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
6499                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
6500                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
6501                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
6502                             return Some(expr8_0);
6503                         }
6504                         &IntCC::SignedLessThanOrEqual => {
6505                             // Rule at src/isa/x64/lower.isle line 1515.
6506                             let expr0_0: Type = I64X2;
6507                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6508                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6509                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
6510                             let expr4_0: Type = I64X2;
6511                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
6512                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
6513                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
6514                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
6515                             return Some(expr8_0);
6516                         }
6517                         _ => {}
6518                     }
6519                 }
6520                 if let Some(pattern6_0) = C::fits_in_64(ctx, pattern5_0) {
6521                     // Rule at src/isa/x64/lower.isle line 1451.
6522                     let expr0_0 = C::raw_operand_size_of_type(ctx, pattern6_0);
6523                     let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern4_1)?;
6524                     let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6525                     let expr3_0 = constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?;
6526                     let expr4_0 = C::intcc_to_cc(ctx, pattern2_2);
6527                     let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
6528                     let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
6529                     let expr7_0 = C::output(ctx, expr6_0);
6530                     return Some(expr7_0);
6531                 }
6532                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
6533                     match pattern2_2 {
6534                         &IntCC::Equal => {
6535                             // Rule at src/isa/x64/lower.isle line 1460.
6536                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6537                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6538                             let expr2_0 =
6539                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
6540                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6541                             return Some(expr3_0);
6542                         }
6543                         &IntCC::NotEqual => {
6544                             // Rule at src/isa/x64/lower.isle line 1464.
6545                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6546                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6547                             let expr2_0 =
6548                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
6549                             let expr3_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
6550                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
6551                             let expr5_0 = constructor_x64_pxor(ctx, expr2_0, &expr4_0)?;
6552                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6553                             return Some(expr6_0);
6554                         }
6555                         &IntCC::SignedGreaterThan => {
6556                             // Rule at src/isa/x64/lower.isle line 1471.
6557                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6558                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6559                             let expr2_0 =
6560                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
6561                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6562                             return Some(expr3_0);
6563                         }
6564                         &IntCC::SignedGreaterThanOrEqual => {
6565                             // Rule at src/isa/x64/lower.isle line 1496.
6566                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6567                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6568                             let expr2_0 =
6569                                 constructor_x64_pmaxs(ctx, pattern6_0, expr0_0, &expr1_0)?;
6570                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6571                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
6572                             let expr5_0 =
6573                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6574                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6575                             return Some(expr6_0);
6576                         }
6577                         &IntCC::SignedLessThan => {
6578                             // Rule at src/isa/x64/lower.isle line 1473.
6579                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6580                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6581                             let expr2_0 =
6582                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
6583                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6584                             return Some(expr3_0);
6585                         }
6586                         &IntCC::SignedLessThanOrEqual => {
6587                             // Rule at src/isa/x64/lower.isle line 1499.
6588                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6589                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6590                             let expr2_0 =
6591                                 constructor_x64_pmins(ctx, pattern6_0, expr0_0, &expr1_0)?;
6592                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6593                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
6594                             let expr5_0 =
6595                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6596                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6597                             return Some(expr6_0);
6598                         }
6599                         &IntCC::UnsignedGreaterThan => {
6600                             // Rule at src/isa/x64/lower.isle line 1475.
6601                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6602                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6603                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
6604                             let expr3_0 =
6605                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr2_0)?;
6606                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
6607                             let expr5_0 =
6608                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6609                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
6610                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
6611                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
6612                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
6613                             return Some(expr9_0);
6614                         }
6615                         &IntCC::UnsignedGreaterThanOrEqual => {
6616                             // Rule at src/isa/x64/lower.isle line 1502.
6617                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6618                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6619                             let expr2_0 =
6620                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr1_0)?;
6621                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6622                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
6623                             let expr5_0 =
6624                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6625                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6626                             return Some(expr6_0);
6627                         }
6628                         &IntCC::UnsignedLessThan => {
6629                             // Rule at src/isa/x64/lower.isle line 1485.
6630                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6631                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6632                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
6633                             let expr3_0 =
6634                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr2_0)?;
6635                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
6636                             let expr5_0 =
6637                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6638                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
6639                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
6640                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
6641                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
6642                             return Some(expr9_0);
6643                         }
6644                         &IntCC::UnsignedLessThanOrEqual => {
6645                             // Rule at src/isa/x64/lower.isle line 1505.
6646                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6647                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6648                             let expr2_0 =
6649                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr1_0)?;
6650                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6651                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
6652                             let expr5_0 =
6653                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6654                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6655                             return Some(expr6_0);
6656                         }
6657                         _ => {}
6658                     }
6659                 }
6660             }
6661         }
6662         &InstructionData::Unary {
6663             opcode: ref pattern2_0,
6664             arg: pattern2_1,
6665         } => {
6666             match pattern2_0 {
6667                 &Opcode::IsNull => {
6668                     let pattern4_0 = C::value_type(ctx, pattern2_1);
6669                     if pattern4_0 == R64 {
6670                         // Rule at src/isa/x64/lower.isle line 2097.
6671                         let expr0_0 = OperandSize::Size64;
6672                         let expr1_0: u32 = 0;
6673                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
6674                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
6675                         let expr4_0 = CC::Z;
6676                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
6677                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
6678                         let expr7_0 = C::output(ctx, expr6_0);
6679                         return Some(expr7_0);
6680                     }
6681                 }
6682                 &Opcode::IsInvalid => {
6683                     let pattern4_0 = C::value_type(ctx, pattern2_1);
6684                     if pattern4_0 == R64 {
6685                         // Rule at src/isa/x64/lower.isle line 2105.
6686                         let expr0_0 = OperandSize::Size64;
6687                         let expr1_0: u32 = 4294967295;
6688                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
6689                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
6690                         let expr4_0 = CC::Z;
6691                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
6692                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
6693                         let expr7_0 = C::output(ctx, expr6_0);
6694                         return Some(expr7_0);
6695                     }
6696                 }
6697                 _ => {}
6698             }
6699         }
6700         _ => {}
6701     }
6702     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
6703         let pattern2_0 = C::value_type(ctx, pattern1_0);
6704         if pattern2_0 == B128 {
6705             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6706             match &pattern4_0 {
6707                 &InstructionData::UnaryBool {
6708                     opcode: ref pattern5_0,
6709                     imm: pattern5_1,
6710                 } => {
6711                     if let &Opcode::Bconst = pattern5_0 {
6712                         if pattern5_1 == true {
6713                             // Rule at src/isa/x64/lower.isle line 39.
6714                             let expr0_0: Type = B64;
6715                             let expr1_0: u64 = 1;
6716                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
6717                             let expr3_0: Type = B64;
6718                             let expr4_0: u64 = 0;
6719                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
6720                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
6721                             let expr7_0 = C::output(ctx, expr6_0);
6722                             return Some(expr7_0);
6723                         }
6724                         if pattern5_1 == false {
6725                             // Rule at src/isa/x64/lower.isle line 34.
6726                             let expr0_0: Type = B64;
6727                             let expr1_0: u64 = 0;
6728                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
6729                             let expr3_0: Type = B64;
6730                             let expr4_0: u64 = 0;
6731                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
6732                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
6733                             let expr7_0 = C::output(ctx, expr6_0);
6734                             return Some(expr7_0);
6735                         }
6736                     }
6737                 }
6738                 &InstructionData::Binary {
6739                     opcode: ref pattern5_0,
6740                     args: ref pattern5_1,
6741                 } => {
6742                     match pattern5_0 {
6743                         &Opcode::Band => {
6744                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6745                             // Rule at src/isa/x64/lower.isle line 344.
6746                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6747                             let expr1_0: usize = 0;
6748                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6749                             let expr3_0: usize = 1;
6750                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6751                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6752                             let expr6_0: Type = I64;
6753                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
6754                             let expr8_0 = constructor_x64_and(ctx, expr6_0, expr2_0, &expr7_0)?;
6755                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
6756                             let expr10_0 = C::output(ctx, expr9_0);
6757                             return Some(expr10_0);
6758                         }
6759                         &Opcode::Bor => {
6760                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6761                             // Rule at src/isa/x64/lower.isle line 410.
6762                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6763                             let expr1_0: usize = 0;
6764                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6765                             let expr3_0: usize = 1;
6766                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6767                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6768                             let expr6_0: Type = I64;
6769                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
6770                             let expr8_0 = constructor_x64_or(ctx, expr6_0, expr2_0, &expr7_0)?;
6771                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
6772                             let expr10_0 = C::output(ctx, expr9_0);
6773                             return Some(expr10_0);
6774                         }
6775                         &Opcode::Bxor => {
6776                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6777                             // Rule at src/isa/x64/lower.isle line 468.
6778                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6779                             let expr1_0: usize = 0;
6780                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6781                             let expr3_0: usize = 1;
6782                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6783                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6784                             let expr6_0: Type = I64;
6785                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
6786                             let expr8_0 = constructor_x64_xor(ctx, expr6_0, expr2_0, &expr7_0)?;
6787                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
6788                             let expr10_0 = C::output(ctx, expr9_0);
6789                             return Some(expr10_0);
6790                         }
6791                         _ => {}
6792                     }
6793                 }
6794                 &InstructionData::Unary {
6795                     opcode: ref pattern5_0,
6796                     arg: pattern5_1,
6797                 } => {
6798                     if let &Opcode::Bnot = pattern5_0 {
6799                         // Rule at src/isa/x64/lower.isle line 1269.
6800                         let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
6801                         let expr1_0 = C::output(ctx, expr0_0);
6802                         return Some(expr1_0);
6803                     }
6804                 }
6805                 _ => {}
6806             }
6807         }
6808         if pattern2_0 == I8 {
6809             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6810             if let &InstructionData::Unary {
6811                 opcode: ref pattern5_0,
6812                 arg: pattern5_1,
6813             } = &pattern4_0
6814             {
6815                 if let &Opcode::Bitrev = pattern5_0 {
6816                     // Rule at src/isa/x64/lower.isle line 2019.
6817                     let expr0_0: Type = I32;
6818                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6819                     let expr2_0 = constructor_do_bitrev8(ctx, expr0_0, expr1_0)?;
6820                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6821                     return Some(expr3_0);
6822                 }
6823             }
6824         }
6825         if pattern2_0 == I16 {
6826             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6827             if let &InstructionData::Unary {
6828                 opcode: ref pattern5_0,
6829                 arg: pattern5_1,
6830             } = &pattern4_0
6831             {
6832                 if let &Opcode::Bitrev = pattern5_0 {
6833                     // Rule at src/isa/x64/lower.isle line 2022.
6834                     let expr0_0: Type = I32;
6835                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6836                     let expr2_0 = constructor_do_bitrev16(ctx, expr0_0, expr1_0)?;
6837                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6838                     return Some(expr3_0);
6839                 }
6840             }
6841         }
6842         if pattern2_0 == I32 {
6843             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6844             if let &InstructionData::Unary {
6845                 opcode: ref pattern5_0,
6846                 arg: pattern5_1,
6847             } = &pattern4_0
6848             {
6849                 if let &Opcode::Bitrev = pattern5_0 {
6850                     // Rule at src/isa/x64/lower.isle line 2025.
6851                     let expr0_0: Type = I32;
6852                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6853                     let expr2_0 = constructor_do_bitrev32(ctx, expr0_0, expr1_0)?;
6854                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6855                     return Some(expr3_0);
6856                 }
6857             }
6858         }
6859         if pattern2_0 == I64 {
6860             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6861             if let &InstructionData::Unary {
6862                 opcode: ref pattern5_0,
6863                 arg: pattern5_1,
6864             } = &pattern4_0
6865             {
6866                 match pattern5_0 {
6867                     &Opcode::Bitrev => {
6868                         // Rule at src/isa/x64/lower.isle line 2028.
6869                         let expr0_0: Type = I64;
6870                         let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6871                         let expr2_0 = constructor_do_bitrev64(ctx, expr0_0, expr1_0)?;
6872                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6873                         return Some(expr3_0);
6874                     }
6875                     &Opcode::Uextend => {
6876                         if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
6877                             if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
6878                                 let pattern9_0 = C::value_type(ctx, pattern8_0);
6879                                 if pattern9_0 == I32 {
6880                                     let pattern11_0 = C::inst_data(ctx, pattern7_0);
6881                                     match &pattern11_0 {
6882                                         &InstructionData::Binary {
6883                                             opcode: ref pattern12_0,
6884                                             args: ref pattern12_1,
6885                                         } => {
6886                                             match pattern12_0 {
6887                                                 &Opcode::Iadd => {
6888                                                     let (pattern14_0, pattern14_1) =
6889                                                         C::unpack_value_array_2(ctx, pattern12_1);
6890                                                     // Rule at src/isa/x64/lower.isle line 2144.
6891                                                     let expr0_0 =
6892                                                         constructor_output_value(ctx, pattern5_1)?;
6893                                                     return Some(expr0_0);
6894                                                 }
6895                                                 &Opcode::Isub => {
6896                                                     let (pattern14_0, pattern14_1) =
6897                                                         C::unpack_value_array_2(ctx, pattern12_1);
6898                                                     // Rule at src/isa/x64/lower.isle line 2150.
6899                                                     let expr0_0 =
6900                                                         constructor_output_value(ctx, pattern5_1)?;
6901                                                     return Some(expr0_0);
6902                                                 }
6903                                                 &Opcode::Imul => {
6904                                                     let (pattern14_0, pattern14_1) =
6905                                                         C::unpack_value_array_2(ctx, pattern12_1);
6906                                                     // Rule at src/isa/x64/lower.isle line 2153.
6907                                                     let expr0_0 =
6908                                                         constructor_output_value(ctx, pattern5_1)?;
6909                                                     return Some(expr0_0);
6910                                                 }
6911                                                 &Opcode::IaddIfcout => {
6912                                                     let (pattern14_0, pattern14_1) =
6913                                                         C::unpack_value_array_2(ctx, pattern12_1);
6914                                                     // Rule at src/isa/x64/lower.isle line 2147.
6915                                                     let expr0_0 =
6916                                                         constructor_output_value(ctx, pattern5_1)?;
6917                                                     return Some(expr0_0);
6918                                                 }
6919                                                 &Opcode::Band => {
6920                                                     let (pattern14_0, pattern14_1) =
6921                                                         C::unpack_value_array_2(ctx, pattern12_1);
6922                                                     // Rule at src/isa/x64/lower.isle line 2156.
6923                                                     let expr0_0 =
6924                                                         constructor_output_value(ctx, pattern5_1)?;
6925                                                     return Some(expr0_0);
6926                                                 }
6927                                                 &Opcode::Bor => {
6928                                                     let (pattern14_0, pattern14_1) =
6929                                                         C::unpack_value_array_2(ctx, pattern12_1);
6930                                                     // Rule at src/isa/x64/lower.isle line 2159.
6931                                                     let expr0_0 =
6932                                                         constructor_output_value(ctx, pattern5_1)?;
6933                                                     return Some(expr0_0);
6934                                                 }
6935                                                 &Opcode::Bxor => {
6936                                                     let (pattern14_0, pattern14_1) =
6937                                                         C::unpack_value_array_2(ctx, pattern12_1);
6938                                                     // Rule at src/isa/x64/lower.isle line 2162.
6939                                                     let expr0_0 =
6940                                                         constructor_output_value(ctx, pattern5_1)?;
6941                                                     return Some(expr0_0);
6942                                                 }
6943                                                 &Opcode::Ishl => {
6944                                                     let (pattern14_0, pattern14_1) =
6945                                                         C::unpack_value_array_2(ctx, pattern12_1);
6946                                                     // Rule at src/isa/x64/lower.isle line 2165.
6947                                                     let expr0_0 =
6948                                                         constructor_output_value(ctx, pattern5_1)?;
6949                                                     return Some(expr0_0);
6950                                                 }
6951                                                 &Opcode::Ushr => {
6952                                                     let (pattern14_0, pattern14_1) =
6953                                                         C::unpack_value_array_2(ctx, pattern12_1);
6954                                                     // Rule at src/isa/x64/lower.isle line 2168.
6955                                                     let expr0_0 =
6956                                                         constructor_output_value(ctx, pattern5_1)?;
6957                                                     return Some(expr0_0);
6958                                                 }
6959                                                 _ => {}
6960                                             }
6961                                         }
6962                                         &InstructionData::Load {
6963                                             opcode: ref pattern12_0,
6964                                             arg: pattern12_1,
6965                                             flags: pattern12_2,
6966                                             offset: pattern12_3,
6967                                         } => {
6968                                             if let &Opcode::Uload32 = pattern12_0 {
6969                                                 // Rule at src/isa/x64/lower.isle line 2171.
6970                                                 let expr0_0 =
6971                                                     constructor_output_value(ctx, pattern5_1)?;
6972                                                 return Some(expr0_0);
6973                                             }
6974                                         }
6975                                         _ => {}
6976                                     }
6977                                 }
6978                             }
6979                         }
6980                         let pattern7_0 = C::value_type(ctx, pattern5_1);
6981                         if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
6982                             // Rule at src/isa/x64/lower.isle line 2126.
6983                             let expr0_0: Type = I64;
6984                             let expr1_0 = ExtendKind::Zero;
6985                             let expr2_0 =
6986                                 constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
6987                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6988                             return Some(expr3_0);
6989                         }
6990                     }
6991                     _ => {}
6992                 }
6993             }
6994         }
6995         if pattern2_0 == I128 {
6996             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6997             match &pattern4_0 {
6998                 &InstructionData::UnaryImm {
6999                     opcode: ref pattern5_0,
7000                     imm: pattern5_1,
7001                 } => {
7002                     if let &Opcode::Iconst = pattern5_0 {
7003                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
7004                         // Rule at src/isa/x64/lower.isle line 15.
7005                         let expr0_0: Type = I64;
7006                         let expr1_0 = constructor_imm(ctx, expr0_0, pattern7_0)?;
7007                         let expr2_0: Type = I64;
7008                         let expr3_0: u64 = 0;
7009                         let expr4_0 = constructor_imm(ctx, expr2_0, expr3_0)?;
7010                         let expr5_0 = C::value_regs(ctx, expr1_0, expr4_0);
7011                         let expr6_0 = C::output(ctx, expr5_0);
7012                         return Some(expr6_0);
7013                     }
7014                 }
7015                 &InstructionData::Binary {
7016                     opcode: ref pattern5_0,
7017                     args: ref pattern5_1,
7018                 } => {
7019                     match pattern5_0 {
7020                         &Opcode::Iadd => {
7021                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7022                             // Rule at src/isa/x64/lower.isle line 111.
7023                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7024                             let expr1_0: usize = 0;
7025                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7026                             let expr3_0: usize = 1;
7027                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7028                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7029                             let expr6_0: usize = 0;
7030                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7031                             let expr8_0: usize = 1;
7032                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7033                             let expr10_0: Type = I64;
7034                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7035                             let expr12_0 = constructor_x64_add_with_flags_paired(
7036                                 ctx, expr10_0, expr2_0, &expr11_0,
7037                             )?;
7038                             let expr13_0: Type = I64;
7039                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7040                             let expr15_0 =
7041                                 constructor_x64_adc_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
7042                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
7043                             let expr17_0 = C::output(ctx, expr16_0);
7044                             return Some(expr17_0);
7045                         }
7046                         &Opcode::Isub => {
7047                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7048                             // Rule at src/isa/x64/lower.isle line 257.
7049                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7050                             let expr1_0: usize = 0;
7051                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7052                             let expr3_0: usize = 1;
7053                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7054                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7055                             let expr6_0: usize = 0;
7056                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7057                             let expr8_0: usize = 1;
7058                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7059                             let expr10_0: Type = I64;
7060                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7061                             let expr12_0 = constructor_x64_sub_with_flags_paired(
7062                                 ctx, expr10_0, expr2_0, &expr11_0,
7063                             )?;
7064                             let expr13_0: Type = I64;
7065                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7066                             let expr15_0 =
7067                                 constructor_x64_sbb_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
7068                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
7069                             let expr17_0 = C::output(ctx, expr16_0);
7070                             return Some(expr17_0);
7071                         }
7072                         &Opcode::Imul => {
7073                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7074                             // Rule at src/isa/x64/lower.isle line 957.
7075                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7076                             let expr1_0: usize = 0;
7077                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7078                             let expr3_0: usize = 1;
7079                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7080                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7081                             let expr6_0: usize = 0;
7082                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7083                             let expr8_0: usize = 1;
7084                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7085                             let expr10_0: Type = I64;
7086                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7087                             let expr12_0 = constructor_x64_mul(ctx, expr10_0, expr2_0, &expr11_0)?;
7088                             let expr13_0: Type = I64;
7089                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7090                             let expr15_0 = constructor_x64_mul(ctx, expr13_0, expr4_0, &expr14_0)?;
7091                             let expr16_0: Type = I64;
7092                             let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr15_0);
7093                             let expr18_0 = constructor_x64_add(ctx, expr16_0, expr12_0, &expr17_0)?;
7094                             let expr19_0: Type = I64;
7095                             let expr20_0 = C::gpr_to_gpr_mem(ctx, expr7_0);
7096                             let expr21_0 = constructor_mulhi_u(ctx, expr19_0, expr2_0, &expr20_0)?;
7097                             let expr22_0: usize = 0;
7098                             let expr23_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr22_0)?;
7099                             let expr24_0: usize = 1;
7100                             let expr25_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr24_0)?;
7101                             let expr26_0: Type = I64;
7102                             let expr27_0 = C::gpr_to_gpr_mem_imm(ctx, expr25_0);
7103                             let expr28_0 = constructor_x64_add(ctx, expr26_0, expr18_0, &expr27_0)?;
7104                             let expr29_0 = constructor_value_gprs(ctx, expr23_0, expr28_0)?;
7105                             let expr30_0 = C::output(ctx, expr29_0);
7106                             return Some(expr30_0);
7107                         }
7108                         &Opcode::Band => {
7109                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7110                             // Rule at src/isa/x64/lower.isle line 334.
7111                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7112                             let expr1_0: usize = 0;
7113                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7114                             let expr3_0: usize = 1;
7115                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7116                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7117                             let expr6_0: usize = 0;
7118                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7119                             let expr8_0: usize = 1;
7120                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7121                             let expr10_0: Type = I64;
7122                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7123                             let expr12_0 = constructor_x64_and(ctx, expr10_0, expr2_0, &expr11_0)?;
7124                             let expr13_0: Type = I64;
7125                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7126                             let expr15_0 = constructor_x64_and(ctx, expr13_0, expr4_0, &expr14_0)?;
7127                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
7128                             let expr17_0 = C::output(ctx, expr16_0);
7129                             return Some(expr17_0);
7130                         }
7131                         &Opcode::Bor => {
7132                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7133                             // Rule at src/isa/x64/lower.isle line 407.
7134                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7135                             let expr1_0 = C::put_in_regs(ctx, pattern7_1);
7136                             let expr2_0 = constructor_or_i128(ctx, expr0_0, expr1_0)?;
7137                             let expr3_0 = C::output(ctx, expr2_0);
7138                             return Some(expr3_0);
7139                         }
7140                         &Opcode::Bxor => {
7141                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7142                             // Rule at src/isa/x64/lower.isle line 458.
7143                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7144                             let expr1_0: usize = 0;
7145                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7146                             let expr3_0: usize = 1;
7147                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7148                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7149                             let expr6_0: usize = 0;
7150                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7151                             let expr8_0: usize = 1;
7152                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7153                             let expr10_0: Type = I64;
7154                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7155                             let expr12_0 = constructor_x64_xor(ctx, expr10_0, expr2_0, &expr11_0)?;
7156                             let expr13_0: Type = I64;
7157                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7158                             let expr15_0 = constructor_x64_xor(ctx, expr13_0, expr4_0, &expr14_0)?;
7159                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
7160                             let expr17_0 = C::output(ctx, expr16_0);
7161                             return Some(expr17_0);
7162                         }
7163                         &Opcode::Rotl => {
7164                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7165                             // Rule at src/isa/x64/lower.isle line 830.
7166                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7167                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7168                             let expr2_0 = constructor_shl_i128(ctx, expr0_0, expr1_0)?;
7169                             let expr3_0: Type = I64;
7170                             let expr4_0: Type = I64;
7171                             let expr5_0: u64 = 128;
7172                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
7173                             let expr7_0 = C::gpr_new(ctx, expr6_0);
7174                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
7175                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
7176                             let expr10_0 = constructor_shr_i128(ctx, expr0_0, expr9_0)?;
7177                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
7178                             let expr12_0 = C::output(ctx, expr11_0);
7179                             return Some(expr12_0);
7180                         }
7181                         &Opcode::Rotr => {
7182                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7183                             // Rule at src/isa/x64/lower.isle line 870.
7184                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7185                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7186                             let expr2_0 = constructor_shr_i128(ctx, expr0_0, expr1_0)?;
7187                             let expr3_0: Type = I64;
7188                             let expr4_0: Type = I64;
7189                             let expr5_0: u64 = 128;
7190                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
7191                             let expr7_0 = C::gpr_new(ctx, expr6_0);
7192                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
7193                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
7194                             let expr10_0 = constructor_shl_i128(ctx, expr0_0, expr9_0)?;
7195                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
7196                             let expr12_0 = C::output(ctx, expr11_0);
7197                             return Some(expr12_0);
7198                         }
7199                         &Opcode::Ishl => {
7200                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7201                             // Rule at src/isa/x64/lower.isle line 522.
7202                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7203                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
7204                             let expr2_0 = constructor_shl_i128(ctx, expr1_0, expr0_0)?;
7205                             let expr3_0 = C::output(ctx, expr2_0);
7206                             return Some(expr3_0);
7207                         }
7208                         &Opcode::Ushr => {
7209                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7210                             // Rule at src/isa/x64/lower.isle line 623.
7211                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7212                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
7213                             let expr2_0 = constructor_shr_i128(ctx, expr1_0, expr0_0)?;
7214                             let expr3_0 = C::output(ctx, expr2_0);
7215                             return Some(expr3_0);
7216                         }
7217                         &Opcode::Sshr => {
7218                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7219                             // Rule at src/isa/x64/lower.isle line 728.
7220                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7221                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
7222                             let expr2_0 = constructor_sar_i128(ctx, expr1_0, expr0_0)?;
7223                             let expr3_0 = C::output(ctx, expr2_0);
7224                             return Some(expr3_0);
7225                         }
7226                         _ => {}
7227                     }
7228                 }
7229                 &InstructionData::Unary {
7230                     opcode: ref pattern5_0,
7231                     arg: pattern5_1,
7232                 } => {
7233                     match pattern5_0 {
7234                         &Opcode::Bnot => {
7235                             // Rule at src/isa/x64/lower.isle line 1266.
7236                             let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
7237                             let expr1_0 = C::output(ctx, expr0_0);
7238                             return Some(expr1_0);
7239                         }
7240                         &Opcode::Bitrev => {
7241                             // Rule at src/isa/x64/lower.isle line 2031.
7242                             let expr0_0: Type = I64;
7243                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
7244                             let expr2_0: usize = 1;
7245                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
7246                             let expr4_0 = constructor_do_bitrev64(ctx, expr0_0, expr3_0)?;
7247                             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
7248                             let expr6_0: Type = I64;
7249                             let expr7_0 = C::put_in_regs(ctx, pattern5_1);
7250                             let expr8_0: usize = 0;
7251                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr7_0, expr8_0)?;
7252                             let expr10_0 = constructor_do_bitrev64(ctx, expr6_0, expr9_0)?;
7253                             let expr11_0 = C::gpr_to_reg(ctx, expr10_0);
7254                             let expr12_0 = C::value_regs(ctx, expr5_0, expr11_0);
7255                             let expr13_0 = C::output(ctx, expr12_0);
7256                             return Some(expr13_0);
7257                         }
7258                         &Opcode::Clz => {
7259                             // Rule at src/isa/x64/lower.isle line 1801.
7260                             let expr0_0: Type = I64;
7261                             let expr1_0: Type = I64;
7262                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
7263                             let expr3_0: usize = 1;
7264                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
7265                             let expr5_0 = constructor_do_clz(ctx, expr0_0, expr1_0, expr4_0)?;
7266                             let expr6_0: Type = I64;
7267                             let expr7_0: Type = I64;
7268                             let expr8_0: Type = I64;
7269                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
7270                             let expr10_0: usize = 0;
7271                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
7272                             let expr12_0 = constructor_do_clz(ctx, expr7_0, expr8_0, expr11_0)?;
7273                             let expr13_0: u32 = 64;
7274                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7275                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
7276                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
7277                             let expr17_0 = OperandSize::Size64;
7278                             let expr18_0: u32 = 64;
7279                             let expr19_0 =
7280                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
7281                             let expr20_0: Type = I64;
7282                             let expr21_0 = CC::NZ;
7283                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr5_0);
7284                             let expr23_0 =
7285                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr16_0)?;
7286                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
7287                             let expr25_0 = C::gpr_new(ctx, expr24_0);
7288                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
7289                             let expr27_0: Type = I64;
7290                             let expr28_0: u64 = 0;
7291                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
7292                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
7293                             let expr31_0 = C::output(ctx, expr30_0);
7294                             return Some(expr31_0);
7295                         }
7296                         &Opcode::Ctz => {
7297                             // Rule at src/isa/x64/lower.isle line 1843.
7298                             let expr0_0: Type = I64;
7299                             let expr1_0: Type = I64;
7300                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
7301                             let expr3_0: usize = 0;
7302                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
7303                             let expr5_0 = constructor_do_ctz(ctx, expr0_0, expr1_0, expr4_0)?;
7304                             let expr6_0: Type = I64;
7305                             let expr7_0: Type = I64;
7306                             let expr8_0: Type = I64;
7307                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
7308                             let expr10_0: usize = 1;
7309                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
7310                             let expr12_0 = constructor_do_ctz(ctx, expr7_0, expr8_0, expr11_0)?;
7311                             let expr13_0: u32 = 64;
7312                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7313                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
7314                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
7315                             let expr17_0 = OperandSize::Size64;
7316                             let expr18_0: u32 = 64;
7317                             let expr19_0 =
7318                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
7319                             let expr20_0: Type = I64;
7320                             let expr21_0 = CC::Z;
7321                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr16_0);
7322                             let expr23_0 =
7323                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr5_0)?;
7324                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
7325                             let expr25_0 = C::gpr_new(ctx, expr24_0);
7326                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
7327                             let expr27_0: Type = I64;
7328                             let expr28_0: u64 = 0;
7329                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
7330                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
7331                             let expr31_0 = C::output(ctx, expr30_0);
7332                             return Some(expr31_0);
7333                         }
7334                         &Opcode::Popcnt => {
7335                             // Rule at src/isa/x64/lower.isle line 1895.
7336                             let expr0_0: Type = I64;
7337                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
7338                             let expr2_0: usize = 0;
7339                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
7340                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
7341                             let expr5_0: Type = I64;
7342                             let expr6_0 = C::put_in_regs(ctx, pattern5_1);
7343                             let expr7_0: usize = 1;
7344                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
7345                             let expr9_0 = constructor_do_popcnt(ctx, expr5_0, expr8_0)?;
7346                             let expr10_0: Type = I64;
7347                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7348                             let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
7349                             let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
7350                             let expr14_0: Type = I64;
7351                             let expr15_0: u64 = 0;
7352                             let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
7353                             let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
7354                             let expr18_0 = C::output(ctx, expr17_0);
7355                             return Some(expr18_0);
7356                         }
7357                         &Opcode::Bint => {
7358                             // Rule at src/isa/x64/lower.isle line 2246.
7359                             let expr0_0: Type = I64;
7360                             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
7361                             let expr2_0: u32 = 1;
7362                             let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
7363                             let expr4_0 = C::gpr_mem_imm_new(ctx, &expr3_0);
7364                             let expr5_0 = constructor_x64_and(ctx, expr0_0, expr1_0, &expr4_0)?;
7365                             let expr6_0 = C::gpr_to_reg(ctx, expr5_0);
7366                             let expr7_0: Type = I64;
7367                             let expr8_0: u64 = 0;
7368                             let expr9_0 = constructor_imm(ctx, expr7_0, expr8_0)?;
7369                             let expr10_0 = C::value_regs(ctx, expr6_0, expr9_0);
7370                             let expr11_0 = C::output(ctx, expr10_0);
7371                             return Some(expr11_0);
7372                         }
7373                         &Opcode::Uextend => {
7374                             let pattern7_0 = C::value_type(ctx, pattern5_1);
7375                             if pattern7_0 == I64 {
7376                                 // Rule at src/isa/x64/lower.isle line 2118.
7377                                 let expr0_0 = C::put_in_reg(ctx, pattern5_1);
7378                                 let expr1_0: Type = I64;
7379                                 let expr2_0: u64 = 0;
7380                                 let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
7381                                 let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
7382                                 let expr5_0 = C::output(ctx, expr4_0);
7383                                 return Some(expr5_0);
7384                             }
7385                             if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
7386                                 // Rule at src/isa/x64/lower.isle line 2122.
7387                                 let expr0_0: Type = I64;
7388                                 let expr1_0 = ExtendKind::Zero;
7389                                 let expr2_0 =
7390                                     constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
7391                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
7392                                 let expr4_0: Type = I64;
7393                                 let expr5_0: u64 = 0;
7394                                 let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
7395                                 let expr7_0 = C::value_regs(ctx, expr3_0, expr6_0);
7396                                 let expr8_0 = C::output(ctx, expr7_0);
7397                                 return Some(expr8_0);
7398                             }
7399                         }
7400                         _ => {}
7401                     }
7402                 }
7403                 &InstructionData::BinaryImm64 {
7404                     opcode: ref pattern5_0,
7405                     arg: pattern5_1,
7406                     imm: pattern5_2,
7407                 } => {
7408                     if let &Opcode::IaddImm = pattern5_0 {
7409                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
7410                         // Rule at src/isa/x64/lower.isle line 210.
7411                         let expr0_0 = C::put_in_regs(ctx, pattern5_1);
7412                         let expr1_0: usize = 0;
7413                         let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7414                         let expr3_0: usize = 1;
7415                         let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7416                         let expr5_0: Type = I64;
7417                         let expr6_0 = constructor_imm(ctx, expr5_0, pattern7_0)?;
7418                         let expr7_0 = C::gpr_new(ctx, expr6_0);
7419                         let expr8_0: Type = I64;
7420                         let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7421                         let expr10_0 =
7422                             constructor_x64_add_with_flags_paired(ctx, expr8_0, expr2_0, &expr9_0)?;
7423                         let expr11_0: Type = I64;
7424                         let expr12_0: u32 = 0;
7425                         let expr13_0 = RegMemImm::Imm { simm32: expr12_0 };
7426                         let expr14_0 = C::gpr_mem_imm_new(ctx, &expr13_0);
7427                         let expr15_0 =
7428                             constructor_x64_adc_paired(ctx, expr11_0, expr4_0, &expr14_0)?;
7429                         let expr16_0 = constructor_with_flags(ctx, &expr10_0, &expr15_0)?;
7430                         let expr17_0 = C::output(ctx, expr16_0);
7431                         return Some(expr17_0);
7432                     }
7433                 }
7434                 _ => {}
7435             }
7436         }
7437         if pattern2_0 == F32 {
7438             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7439             match &pattern4_0 {
7440                 &InstructionData::Binary {
7441                     opcode: ref pattern5_0,
7442                     args: ref pattern5_1,
7443                 } => {
7444                     match pattern5_0 {
7445                         &Opcode::Fadd => {
7446                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7447                             // Rule at src/isa/x64/lower.isle line 2269.
7448                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7449                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7450                             let expr2_0 = constructor_x64_addss(ctx, expr0_0, &expr1_0)?;
7451                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7452                             return Some(expr3_0);
7453                         }
7454                         &Opcode::Fsub => {
7455                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7456                             // Rule at src/isa/x64/lower.isle line 2280.
7457                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7458                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7459                             let expr2_0 = constructor_x64_subss(ctx, expr0_0, &expr1_0)?;
7460                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7461                             return Some(expr3_0);
7462                         }
7463                         &Opcode::Fmul => {
7464                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7465                             // Rule at src/isa/x64/lower.isle line 2291.
7466                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7467                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7468                             let expr2_0 = constructor_x64_mulss(ctx, expr0_0, &expr1_0)?;
7469                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7470                             return Some(expr3_0);
7471                         }
7472                         &Opcode::Fdiv => {
7473                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7474                             // Rule at src/isa/x64/lower.isle line 2302.
7475                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7476                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7477                             let expr2_0 = constructor_x64_divss(ctx, expr0_0, &expr1_0)?;
7478                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7479                             return Some(expr3_0);
7480                         }
7481                         &Opcode::Fmin => {
7482                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7483                             // Rule at src/isa/x64/lower.isle line 2323.
7484                             let expr0_0: Type = F32;
7485                             let expr1_0: bool = true;
7486                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7487                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7488                             let expr4_0 = constructor_xmm_min_max_seq(
7489                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
7490                             )?;
7491                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
7492                             return Some(expr5_0);
7493                         }
7494                         &Opcode::FminPseudo => {
7495                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7496                             // Rule at src/isa/x64/lower.isle line 2492.
7497                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7498                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7499                             let expr2_0 = constructor_x64_minss(ctx, expr0_0, expr1_0)?;
7500                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7501                             return Some(expr3_0);
7502                         }
7503                         &Opcode::Fmax => {
7504                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7505                             // Rule at src/isa/x64/lower.isle line 2395.
7506                             let expr0_0: Type = F32;
7507                             let expr1_0: bool = false;
7508                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7509                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7510                             let expr4_0 = constructor_xmm_min_max_seq(
7511                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
7512                             )?;
7513                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
7514                             return Some(expr5_0);
7515                         }
7516                         &Opcode::FmaxPseudo => {
7517                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7518                             // Rule at src/isa/x64/lower.isle line 2503.
7519                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7520                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7521                             let expr2_0 = constructor_x64_maxss(ctx, expr0_0, expr1_0)?;
7522                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7523                             return Some(expr3_0);
7524                         }
7525                         _ => {}
7526                     }
7527                 }
7528                 &InstructionData::Unary {
7529                     opcode: ref pattern5_0,
7530                     arg: pattern5_1,
7531                 } => {
7532                     if let &Opcode::Sqrt = pattern5_0 {
7533                         // Rule at src/isa/x64/lower.isle line 2312.
7534                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7535                         let expr1_0 = constructor_x64_sqrtss(ctx, expr0_0)?;
7536                         let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7537                         return Some(expr2_0);
7538                     }
7539                 }
7540                 &InstructionData::Load {
7541                     opcode: ref pattern5_0,
7542                     arg: pattern5_1,
7543                     flags: pattern5_2,
7544                     offset: pattern5_3,
7545                 } => {
7546                     if let &Opcode::Load = pattern5_0 {
7547                         // Rule at src/isa/x64/lower.isle line 2546.
7548                         let expr0_0 =
7549                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7550                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7551                         let expr2_0 = constructor_x64_movss_load(ctx, &expr1_0)?;
7552                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7553                         return Some(expr3_0);
7554                     }
7555                 }
7556                 _ => {}
7557             }
7558         }
7559         if pattern2_0 == F64 {
7560             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7561             match &pattern4_0 {
7562                 &InstructionData::Binary {
7563                     opcode: ref pattern5_0,
7564                     args: ref pattern5_1,
7565                 } => {
7566                     match pattern5_0 {
7567                         &Opcode::Fadd => {
7568                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7569                             // Rule at src/isa/x64/lower.isle line 2271.
7570                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7571                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7572                             let expr2_0 = constructor_x64_addsd(ctx, expr0_0, &expr1_0)?;
7573                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7574                             return Some(expr3_0);
7575                         }
7576                         &Opcode::Fsub => {
7577                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7578                             // Rule at src/isa/x64/lower.isle line 2282.
7579                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7580                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7581                             let expr2_0 = constructor_x64_subsd(ctx, expr0_0, &expr1_0)?;
7582                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7583                             return Some(expr3_0);
7584                         }
7585                         &Opcode::Fmul => {
7586                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7587                             // Rule at src/isa/x64/lower.isle line 2293.
7588                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7589                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7590                             let expr2_0 = constructor_x64_mulsd(ctx, expr0_0, &expr1_0)?;
7591                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7592                             return Some(expr3_0);
7593                         }
7594                         &Opcode::Fdiv => {
7595                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7596                             // Rule at src/isa/x64/lower.isle line 2304.
7597                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7598                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7599                             let expr2_0 = constructor_x64_divsd(ctx, expr0_0, &expr1_0)?;
7600                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7601                             return Some(expr3_0);
7602                         }
7603                         &Opcode::Fmin => {
7604                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7605                             // Rule at src/isa/x64/lower.isle line 2325.
7606                             let expr0_0: Type = F64;
7607                             let expr1_0: bool = true;
7608                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7609                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7610                             let expr4_0 = constructor_xmm_min_max_seq(
7611                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
7612                             )?;
7613                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
7614                             return Some(expr5_0);
7615                         }
7616                         &Opcode::FminPseudo => {
7617                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7618                             // Rule at src/isa/x64/lower.isle line 2494.
7619                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7620                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7621                             let expr2_0 = constructor_x64_minsd(ctx, expr0_0, expr1_0)?;
7622                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7623                             return Some(expr3_0);
7624                         }
7625                         &Opcode::Fmax => {
7626                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7627                             // Rule at src/isa/x64/lower.isle line 2397.
7628                             let expr0_0: Type = F64;
7629                             let expr1_0: bool = false;
7630                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7631                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7632                             let expr4_0 = constructor_xmm_min_max_seq(
7633                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
7634                             )?;
7635                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
7636                             return Some(expr5_0);
7637                         }
7638                         &Opcode::FmaxPseudo => {
7639                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7640                             // Rule at src/isa/x64/lower.isle line 2505.
7641                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7642                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7643                             let expr2_0 = constructor_x64_maxsd(ctx, expr0_0, expr1_0)?;
7644                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7645                             return Some(expr3_0);
7646                         }
7647                         _ => {}
7648                     }
7649                 }
7650                 &InstructionData::Unary {
7651                     opcode: ref pattern5_0,
7652                     arg: pattern5_1,
7653                 } => {
7654                     if let &Opcode::Sqrt = pattern5_0 {
7655                         // Rule at src/isa/x64/lower.isle line 2314.
7656                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7657                         let expr1_0 = constructor_x64_sqrtsd(ctx, expr0_0)?;
7658                         let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7659                         return Some(expr2_0);
7660                     }
7661                 }
7662                 &InstructionData::Load {
7663                     opcode: ref pattern5_0,
7664                     arg: pattern5_1,
7665                     flags: pattern5_2,
7666                     offset: pattern5_3,
7667                 } => {
7668                     if let &Opcode::Load = pattern5_0 {
7669                         // Rule at src/isa/x64/lower.isle line 2548.
7670                         let expr0_0 =
7671                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7672                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7673                         let expr2_0 = constructor_x64_movsd_load(ctx, &expr1_0)?;
7674                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7675                         return Some(expr3_0);
7676                     }
7677                 }
7678                 _ => {}
7679             }
7680         }
7681         if pattern2_0 == I8X16 {
7682             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7683             match &pattern4_0 {
7684                 &InstructionData::Binary {
7685                     opcode: ref pattern5_0,
7686                     args: ref pattern5_1,
7687                 } => {
7688                     match pattern5_0 {
7689                         &Opcode::Imin => {
7690                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7691                             // Rule at src/isa/x64/lower.isle line 1405.
7692                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7693                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7694                             let expr2_0 = constructor_x64_pminsb(ctx, expr0_0, &expr1_0)?;
7695                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7696                             return Some(expr3_0);
7697                         }
7698                         &Opcode::Umin => {
7699                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7700                             // Rule at src/isa/x64/lower.isle line 1427.
7701                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7702                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7703                             let expr2_0 = constructor_x64_pminub(ctx, expr0_0, &expr1_0)?;
7704                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7705                             return Some(expr3_0);
7706                         }
7707                         &Opcode::Imax => {
7708                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7709                             // Rule at src/isa/x64/lower.isle line 1394.
7710                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7711                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7712                             let expr2_0 = constructor_x64_pmaxsb(ctx, expr0_0, &expr1_0)?;
7713                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7714                             return Some(expr3_0);
7715                         }
7716                         &Opcode::Umax => {
7717                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7718                             // Rule at src/isa/x64/lower.isle line 1416.
7719                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7720                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7721                             let expr2_0 = constructor_x64_pmaxub(ctx, expr0_0, &expr1_0)?;
7722                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7723                             return Some(expr3_0);
7724                         }
7725                         &Opcode::Ishl => {
7726                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7727                             // Rule at src/isa/x64/lower.isle line 534.
7728                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7729                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7730                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7731                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
7732                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7733                             let expr5_0 = constructor_ishl_i8x16_mask(ctx, &expr4_0)?;
7734                             let expr6_0: Type = I8X16;
7735                             let expr7_0 = ExtKind::None;
7736                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
7737                             let expr9_0: Type = I8X16;
7738                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
7739                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
7740                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
7741                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
7742                             return Some(expr13_0);
7743                         }
7744                         &Opcode::Ushr => {
7745                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7746                             // Rule at src/isa/x64/lower.isle line 633.
7747                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7748                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7749                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7750                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
7751                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7752                             let expr5_0 = constructor_ushr_i8x16_mask(ctx, &expr4_0)?;
7753                             let expr6_0: Type = I8X16;
7754                             let expr7_0 = ExtKind::None;
7755                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
7756                             let expr9_0: Type = I8X16;
7757                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
7758                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
7759                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
7760                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
7761                             return Some(expr13_0);
7762                         }
7763                         &Opcode::Sshr => {
7764                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7765                             let pattern8_0 = C::value_type(ctx, pattern7_1);
7766                             // Rule at src/isa/x64/lower.isle line 749.
7767                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7768                             let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
7769                             let expr2_0 = constructor_x64_punpcklbw(ctx, expr0_0, &expr1_0)?;
7770                             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
7771                             let expr4_0 = constructor_x64_punpckhbw(ctx, expr0_0, &expr3_0)?;
7772                             let expr5_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7773                             let expr6_0 =
7774                                 constructor_sshr_i8x16_bigger_shift(ctx, pattern8_0, &expr5_0)?;
7775                             let expr7_0 = constructor_x64_psraw(ctx, expr2_0, &expr6_0)?;
7776                             let expr8_0 = constructor_x64_psraw(ctx, expr4_0, &expr6_0)?;
7777                             let expr9_0 = C::xmm_to_xmm_mem(ctx, expr8_0);
7778                             let expr10_0 = constructor_x64_packsswb(ctx, expr7_0, &expr9_0)?;
7779                             let expr11_0 = constructor_output_xmm(ctx, expr10_0)?;
7780                             return Some(expr11_0);
7781                         }
7782                         _ => {}
7783                     }
7784                 }
7785                 &InstructionData::Unary {
7786                     opcode: ref pattern5_0,
7787                     arg: pattern5_1,
7788                 } => {
7789                     match pattern5_0 {
7790                         &Opcode::Ineg => {
7791                             // Rule at src/isa/x64/lower.isle line 889.
7792                             let expr0_0: Type = I8X16;
7793                             let expr1_0: u64 = 0;
7794                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7795                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7796                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7797                             let expr5_0 = constructor_x64_psubb(ctx, expr3_0, &expr4_0)?;
7798                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7799                             return Some(expr6_0);
7800                         }
7801                         &Opcode::Iabs => {
7802                             // Rule at src/isa/x64/lower.isle line 1210.
7803                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7804                             let expr1_0 = constructor_x64_pabsb(ctx, &expr0_0)?;
7805                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7806                             return Some(expr2_0);
7807                         }
7808                         &Opcode::Popcnt => {
7809                             // Rule at src/isa/x64/lower.isle line 2002.
7810                             let expr0_0 = C::popcount_4bit_table(ctx);
7811                             let expr1_0: Type = I8X16;
7812                             let expr2_0 = C::popcount_low_mask(ctx);
7813                             let expr3_0 = constructor_x64_xmm_load_const(ctx, expr1_0, expr2_0)?;
7814                             let expr4_0: Type = I8X16;
7815                             let expr5_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7816                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
7817                             let expr7_0 = constructor_sse_and(ctx, expr4_0, expr5_0, &expr6_0)?;
7818                             let expr8_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7819                             let expr9_0: u32 = 4;
7820                             let expr10_0 = RegMemImm::Imm { simm32: expr9_0 };
7821                             let expr11_0 = constructor_mov_rmi_to_xmm(ctx, &expr10_0)?;
7822                             let expr12_0 = constructor_x64_psrlw(ctx, expr8_0, &expr11_0)?;
7823                             let expr13_0: Type = I8X16;
7824                             let expr14_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
7825                             let expr15_0 = constructor_sse_and(ctx, expr13_0, expr12_0, &expr14_0)?;
7826                             let expr16_0: Type = I8X16;
7827                             let expr17_0 = C::popcount_4bit_table(ctx);
7828                             let expr18_0 = constructor_x64_xmm_load_const(ctx, expr16_0, expr17_0)?;
7829                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7830                             let expr20_0 = constructor_x64_pshufb(ctx, expr18_0, &expr19_0)?;
7831                             let expr21_0 = C::xmm_to_xmm_mem(ctx, expr15_0);
7832                             let expr22_0 = constructor_x64_pshufb(ctx, expr18_0, &expr21_0)?;
7833                             let expr23_0 = C::xmm_to_xmm_mem(ctx, expr22_0);
7834                             let expr24_0 = constructor_x64_paddb(ctx, expr20_0, &expr23_0)?;
7835                             let expr25_0 = constructor_output_xmm(ctx, expr24_0)?;
7836                             return Some(expr25_0);
7837                         }
7838                         _ => {}
7839                     }
7840                 }
7841                 _ => {}
7842             }
7843         }
7844         if pattern2_0 == I16X8 {
7845             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7846             match &pattern4_0 {
7847                 &InstructionData::Binary {
7848                     opcode: ref pattern5_0,
7849                     args: ref pattern5_1,
7850                 } => {
7851                     match pattern5_0 {
7852                         &Opcode::Imin => {
7853                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7854                             // Rule at src/isa/x64/lower.isle line 1408.
7855                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7856                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7857                             let expr2_0 = constructor_x64_pminsw(ctx, expr0_0, &expr1_0)?;
7858                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7859                             return Some(expr3_0);
7860                         }
7861                         &Opcode::Umin => {
7862                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7863                             // Rule at src/isa/x64/lower.isle line 1430.
7864                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7865                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7866                             let expr2_0 = constructor_x64_pminuw(ctx, expr0_0, &expr1_0)?;
7867                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7868                             return Some(expr3_0);
7869                         }
7870                         &Opcode::Imax => {
7871                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7872                             // Rule at src/isa/x64/lower.isle line 1397.
7873                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7874                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7875                             let expr2_0 = constructor_x64_pmaxsw(ctx, expr0_0, &expr1_0)?;
7876                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7877                             return Some(expr3_0);
7878                         }
7879                         &Opcode::Umax => {
7880                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7881                             // Rule at src/isa/x64/lower.isle line 1419.
7882                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7883                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7884                             let expr2_0 = constructor_x64_pmaxuw(ctx, expr0_0, &expr1_0)?;
7885                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7886                             return Some(expr3_0);
7887                         }
7888                         &Opcode::Ishl => {
7889                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7890                             // Rule at src/isa/x64/lower.isle line 576.
7891                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7892                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7893                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7894                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
7895                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7896                             return Some(expr4_0);
7897                         }
7898                         &Opcode::Ushr => {
7899                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7900                             // Rule at src/isa/x64/lower.isle line 678.
7901                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7902                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7903                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7904                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
7905                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7906                             return Some(expr4_0);
7907                         }
7908                         &Opcode::Sshr => {
7909                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7910                             // Rule at src/isa/x64/lower.isle line 776.
7911                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7912                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7913                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7914                             let expr3_0 = constructor_x64_psraw(ctx, expr0_0, &expr2_0)?;
7915                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7916                             return Some(expr4_0);
7917                         }
7918                         _ => {}
7919                     }
7920                 }
7921                 &InstructionData::Unary {
7922                     opcode: ref pattern5_0,
7923                     arg: pattern5_1,
7924                 } => {
7925                     match pattern5_0 {
7926                         &Opcode::Ineg => {
7927                             // Rule at src/isa/x64/lower.isle line 892.
7928                             let expr0_0: Type = I16X8;
7929                             let expr1_0: u64 = 0;
7930                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7931                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7932                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7933                             let expr5_0 = constructor_x64_psubw(ctx, expr3_0, &expr4_0)?;
7934                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7935                             return Some(expr6_0);
7936                         }
7937                         &Opcode::Iabs => {
7938                             // Rule at src/isa/x64/lower.isle line 1213.
7939                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7940                             let expr1_0 = constructor_x64_pabsw(ctx, &expr0_0)?;
7941                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7942                             return Some(expr2_0);
7943                         }
7944                         _ => {}
7945                     }
7946                 }
7947                 &InstructionData::Load {
7948                     opcode: ref pattern5_0,
7949                     arg: pattern5_1,
7950                     flags: pattern5_2,
7951                     offset: pattern5_3,
7952                 } => {
7953                     match pattern5_0 {
7954                         &Opcode::Uload8x8 => {
7955                             // Rule at src/isa/x64/lower.isle line 2570.
7956                             let expr0_0 =
7957                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7958                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7959                             let expr2_0 = constructor_x64_pmovzxbw(ctx, &expr1_0)?;
7960                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7961                             return Some(expr3_0);
7962                         }
7963                         &Opcode::Sload8x8 => {
7964                             // Rule at src/isa/x64/lower.isle line 2568.
7965                             let expr0_0 =
7966                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7967                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7968                             let expr2_0 = constructor_x64_pmovsxbw(ctx, &expr1_0)?;
7969                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7970                             return Some(expr3_0);
7971                         }
7972                         _ => {}
7973                     }
7974                 }
7975                 _ => {}
7976             }
7977         }
7978         if pattern2_0 == I32X4 {
7979             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7980             match &pattern4_0 {
7981                 &InstructionData::Binary {
7982                     opcode: ref pattern5_0,
7983                     args: ref pattern5_1,
7984                 } => {
7985                     match pattern5_0 {
7986                         &Opcode::Imin => {
7987                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7988                             // Rule at src/isa/x64/lower.isle line 1411.
7989                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7990                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7991                             let expr2_0 = constructor_x64_pminsd(ctx, expr0_0, &expr1_0)?;
7992                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7993                             return Some(expr3_0);
7994                         }
7995                         &Opcode::Umin => {
7996                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7997                             // Rule at src/isa/x64/lower.isle line 1433.
7998                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7999                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8000                             let expr2_0 = constructor_x64_pminud(ctx, expr0_0, &expr1_0)?;
8001                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8002                             return Some(expr3_0);
8003                         }
8004                         &Opcode::Imax => {
8005                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8006                             // Rule at src/isa/x64/lower.isle line 1400.
8007                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8008                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8009                             let expr2_0 = constructor_x64_pmaxsd(ctx, expr0_0, &expr1_0)?;
8010                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8011                             return Some(expr3_0);
8012                         }
8013                         &Opcode::Umax => {
8014                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8015                             // Rule at src/isa/x64/lower.isle line 1422.
8016                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8017                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8018                             let expr2_0 = constructor_x64_pmaxud(ctx, expr0_0, &expr1_0)?;
8019                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8020                             return Some(expr3_0);
8021                         }
8022                         &Opcode::Ishl => {
8023                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8024                             // Rule at src/isa/x64/lower.isle line 579.
8025                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8026                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8027                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8028                             let expr3_0 = constructor_x64_pslld(ctx, expr0_0, &expr2_0)?;
8029                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8030                             return Some(expr4_0);
8031                         }
8032                         &Opcode::Ushr => {
8033                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8034                             // Rule at src/isa/x64/lower.isle line 681.
8035                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8036                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8037                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8038                             let expr3_0 = constructor_x64_psrld(ctx, expr0_0, &expr2_0)?;
8039                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8040                             return Some(expr4_0);
8041                         }
8042                         &Opcode::Sshr => {
8043                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8044                             // Rule at src/isa/x64/lower.isle line 779.
8045                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8046                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8047                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8048                             let expr3_0 = constructor_x64_psrad(ctx, expr0_0, &expr2_0)?;
8049                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8050                             return Some(expr4_0);
8051                         }
8052                         &Opcode::WideningPairwiseDotProductS => {
8053                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8054                             // Rule at src/isa/x64/lower.isle line 2259.
8055                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8056                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8057                             let expr2_0 = constructor_x64_pmaddwd(ctx, expr0_0, &expr1_0)?;
8058                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8059                             return Some(expr3_0);
8060                         }
8061                         _ => {}
8062                     }
8063                 }
8064                 &InstructionData::Unary {
8065                     opcode: ref pattern5_0,
8066                     arg: pattern5_1,
8067                 } => {
8068                     match pattern5_0 {
8069                         &Opcode::Ineg => {
8070                             // Rule at src/isa/x64/lower.isle line 895.
8071                             let expr0_0: Type = I32X4;
8072                             let expr1_0: u64 = 0;
8073                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
8074                             let expr3_0 = C::xmm_new(ctx, expr2_0);
8075                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8076                             let expr5_0 = constructor_x64_psubd(ctx, expr3_0, &expr4_0)?;
8077                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8078                             return Some(expr6_0);
8079                         }
8080                         &Opcode::Iabs => {
8081                             // Rule at src/isa/x64/lower.isle line 1216.
8082                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8083                             let expr1_0 = constructor_x64_pabsd(ctx, &expr0_0)?;
8084                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8085                             return Some(expr2_0);
8086                         }
8087                         _ => {}
8088                     }
8089                 }
8090                 &InstructionData::Load {
8091                     opcode: ref pattern5_0,
8092                     arg: pattern5_1,
8093                     flags: pattern5_2,
8094                     offset: pattern5_3,
8095                 } => {
8096                     match pattern5_0 {
8097                         &Opcode::Uload16x4 => {
8098                             // Rule at src/isa/x64/lower.isle line 2574.
8099                             let expr0_0 =
8100                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8101                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8102                             let expr2_0 = constructor_x64_pmovzxwd(ctx, &expr1_0)?;
8103                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8104                             return Some(expr3_0);
8105                         }
8106                         &Opcode::Sload16x4 => {
8107                             // Rule at src/isa/x64/lower.isle line 2572.
8108                             let expr0_0 =
8109                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8110                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8111                             let expr2_0 = constructor_x64_pmovsxwd(ctx, &expr1_0)?;
8112                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8113                             return Some(expr3_0);
8114                         }
8115                         _ => {}
8116                     }
8117                 }
8118                 _ => {}
8119             }
8120         }
8121         if pattern2_0 == I64X2 {
8122             let pattern4_0 = C::inst_data(ctx, pattern0_0);
8123             match &pattern4_0 {
8124                 &InstructionData::Binary {
8125                     opcode: ref pattern5_0,
8126                     args: ref pattern5_1,
8127                 } => {
8128                     match pattern5_0 {
8129                         &Opcode::Ishl => {
8130                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8131                             // Rule at src/isa/x64/lower.isle line 582.
8132                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8133                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8134                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8135                             let expr3_0 = constructor_x64_psllq(ctx, expr0_0, &expr2_0)?;
8136                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8137                             return Some(expr4_0);
8138                         }
8139                         &Opcode::Ushr => {
8140                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8141                             // Rule at src/isa/x64/lower.isle line 684.
8142                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8143                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8144                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8145                             let expr3_0 = constructor_x64_psrlq(ctx, expr0_0, &expr2_0)?;
8146                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8147                             return Some(expr4_0);
8148                         }
8149                         &Opcode::Sshr => {
8150                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8151                             // Rule at src/isa/x64/lower.isle line 790.
8152                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8153                             let expr1_0: Type = I64;
8154                             let expr2_0: u8 = 0;
8155                             let expr3_0 = constructor_x64_pextrd(ctx, expr1_0, expr0_0, expr2_0)?;
8156                             let expr4_0: Type = I64;
8157                             let expr5_0: u8 = 1;
8158                             let expr6_0 = constructor_x64_pextrd(ctx, expr4_0, expr0_0, expr5_0)?;
8159                             let expr7_0: Type = I64;
8160                             let expr8_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, expr7_0);
8161                             let expr9_0: Type = I64;
8162                             let expr10_0 = constructor_x64_sar(ctx, expr9_0, expr3_0, &expr8_0)?;
8163                             let expr11_0: Type = I64;
8164                             let expr12_0 = constructor_x64_sar(ctx, expr11_0, expr6_0, &expr8_0)?;
8165                             let expr13_0 = C::gpr_to_gpr_mem(ctx, expr10_0);
8166                             let expr14_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
8167                             let expr15_0 =
8168                                 constructor_make_i64x2_from_lanes(ctx, &expr13_0, &expr14_0)?;
8169                             let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
8170                             return Some(expr16_0);
8171                         }
8172                         _ => {}
8173                     }
8174                 }
8175                 &InstructionData::Unary {
8176                     opcode: ref pattern5_0,
8177                     arg: pattern5_1,
8178                 } => {
8179                     match pattern5_0 {
8180                         &Opcode::Ineg => {
8181                             // Rule at src/isa/x64/lower.isle line 898.
8182                             let expr0_0: Type = I64X2;
8183                             let expr1_0: u64 = 0;
8184                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
8185                             let expr3_0 = C::xmm_new(ctx, expr2_0);
8186                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8187                             let expr5_0 = constructor_x64_psubq(ctx, expr3_0, &expr4_0)?;
8188                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8189                             return Some(expr6_0);
8190                         }
8191                         &Opcode::Iabs => {
8192                             // Rule at src/isa/x64/lower.isle line 1230.
8193                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8194                             let expr1_0: Type = I64X2;
8195                             let expr2_0: u64 = 0;
8196                             let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
8197                             let expr4_0 = C::xmm_new(ctx, expr3_0);
8198                             let expr5_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8199                             let expr6_0 = constructor_x64_psubq(ctx, expr4_0, &expr5_0)?;
8200                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8201                             let expr8_0 =
8202                                 constructor_x64_blendvpd(ctx, expr6_0, &expr7_0, expr6_0)?;
8203                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
8204                             return Some(expr9_0);
8205                         }
8206                         _ => {}
8207                     }
8208                 }
8209                 &InstructionData::Load {
8210                     opcode: ref pattern5_0,
8211                     arg: pattern5_1,
8212                     flags: pattern5_2,
8213                     offset: pattern5_3,
8214                 } => {
8215                     match pattern5_0 {
8216                         &Opcode::Uload32x2 => {
8217                             // Rule at src/isa/x64/lower.isle line 2578.
8218                             let expr0_0 =
8219                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8220                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8221                             let expr2_0 = constructor_x64_pmovzxdq(ctx, &expr1_0)?;
8222                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8223                             return Some(expr3_0);
8224                         }
8225                         &Opcode::Sload32x2 => {
8226                             // Rule at src/isa/x64/lower.isle line 2576.
8227                             let expr0_0 =
8228                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8229                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8230                             let expr2_0 = constructor_x64_pmovsxdq(ctx, &expr1_0)?;
8231                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8232                             return Some(expr3_0);
8233                         }
8234                         _ => {}
8235                     }
8236                 }
8237                 _ => {}
8238             }
8239         }
8240         if pattern2_0 == F32X4 {
8241             let pattern4_0 = C::inst_data(ctx, pattern0_0);
8242             match &pattern4_0 {
8243                 &InstructionData::Binary {
8244                     opcode: ref pattern5_0,
8245                     args: ref pattern5_1,
8246                 } => {
8247                     match pattern5_0 {
8248                         &Opcode::Fadd => {
8249                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8250                             // Rule at src/isa/x64/lower.isle line 2273.
8251                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8252                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8253                             let expr2_0 = constructor_x64_addps(ctx, expr0_0, &expr1_0)?;
8254                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8255                             return Some(expr3_0);
8256                         }
8257                         &Opcode::Fsub => {
8258                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8259                             // Rule at src/isa/x64/lower.isle line 2284.
8260                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8261                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8262                             let expr2_0 = constructor_x64_subps(ctx, expr0_0, &expr1_0)?;
8263                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8264                             return Some(expr3_0);
8265                         }
8266                         &Opcode::Fmul => {
8267                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8268                             // Rule at src/isa/x64/lower.isle line 2295.
8269                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8270                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8271                             let expr2_0 = constructor_x64_mulps(ctx, expr0_0, &expr1_0)?;
8272                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8273                             return Some(expr3_0);
8274                         }
8275                         &Opcode::Fdiv => {
8276                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8277                             // Rule at src/isa/x64/lower.isle line 2306.
8278                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8279                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8280                             let expr2_0 = constructor_x64_divps(ctx, expr0_0, &expr1_0)?;
8281                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8282                             return Some(expr3_0);
8283                         }
8284                         &Opcode::Fmin => {
8285                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8286                             // Rule at src/isa/x64/lower.isle line 2340.
8287                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8288                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8289                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
8290                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8291                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8292                             let expr5_0 = constructor_x64_minps(ctx, expr3_0, expr4_0)?;
8293                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8294                             let expr7_0 = constructor_x64_orps(ctx, expr2_0, &expr6_0)?;
8295                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8296                             let expr9_0 = FcmpImm::Unordered;
8297                             let expr10_0 = constructor_x64_cmpps(ctx, expr7_0, &expr8_0, &expr9_0)?;
8298                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
8299                             let expr12_0 = constructor_x64_orps(ctx, expr7_0, &expr11_0)?;
8300                             let expr13_0: u32 = 10;
8301                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
8302                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
8303                             let expr16_0 = constructor_x64_psrld(ctx, expr10_0, &expr15_0)?;
8304                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
8305                             let expr18_0 = constructor_x64_andnps(ctx, expr16_0, &expr17_0)?;
8306                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
8307                             return Some(expr19_0);
8308                         }
8309                         &Opcode::FminPseudo => {
8310                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8311                             // Rule at src/isa/x64/lower.isle line 2496.
8312                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8313                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8314                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
8315                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8316                             return Some(expr3_0);
8317                         }
8318                         &Opcode::Fmax => {
8319                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8320                             // Rule at src/isa/x64/lower.isle line 2403.
8321                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8322                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8323                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
8324                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8325                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8326                             let expr5_0 = constructor_x64_maxps(ctx, expr3_0, expr4_0)?;
8327                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8328                             let expr7_0 = constructor_x64_xorps(ctx, expr2_0, &expr6_0)?;
8329                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8330                             let expr9_0 = constructor_x64_orps(ctx, expr2_0, &expr8_0)?;
8331                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8332                             let expr11_0 = constructor_x64_subps(ctx, expr9_0, &expr10_0)?;
8333                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
8334                             let expr13_0 = FcmpImm::Unordered;
8335                             let expr14_0 =
8336                                 constructor_x64_cmpps(ctx, expr9_0, &expr12_0, &expr13_0)?;
8337                             let expr15_0: u32 = 10;
8338                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
8339                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
8340                             let expr18_0 = constructor_x64_psrld(ctx, expr14_0, &expr17_0)?;
8341                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8342                             let expr20_0 = constructor_x64_andnps(ctx, expr18_0, &expr19_0)?;
8343                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
8344                             return Some(expr21_0);
8345                         }
8346                         &Opcode::FmaxPseudo => {
8347                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8348                             // Rule at src/isa/x64/lower.isle line 2507.
8349                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8350                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8351                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
8352                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8353                             return Some(expr3_0);
8354                         }
8355                         _ => {}
8356                     }
8357                 }
8358                 &InstructionData::Unary {
8359                     opcode: ref pattern5_0,
8360                     arg: pattern5_1,
8361                 } => {
8362                     match pattern5_0 {
8363                         &Opcode::Sqrt => {
8364                             // Rule at src/isa/x64/lower.isle line 2316.
8365                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8366                             let expr1_0 = constructor_x64_sqrtps(ctx, expr0_0)?;
8367                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8368                             return Some(expr2_0);
8369                         }
8370                         &Opcode::Fabs => {
8371                             // Rule at src/isa/x64/lower.isle line 1238.
8372                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8373                             let expr1_0: Type = F32X4;
8374                             let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
8375                             let expr3_0: u32 = 1;
8376                             let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
8377                             let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
8378                             let expr6_0 = constructor_x64_psrld(ctx, expr2_0, &expr5_0)?;
8379                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
8380                             let expr8_0 = constructor_x64_andps(ctx, expr0_0, &expr7_0)?;
8381                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
8382                             return Some(expr9_0);
8383                         }
8384                         _ => {}
8385                     }
8386                 }
8387                 &InstructionData::Load {
8388                     opcode: ref pattern5_0,
8389                     arg: pattern5_1,
8390                     flags: pattern5_2,
8391                     offset: pattern5_3,
8392                 } => {
8393                     if let &Opcode::Load = pattern5_0 {
8394                         // Rule at src/isa/x64/lower.isle line 2550.
8395                         let expr0_0 =
8396                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8397                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8398                         let expr2_0 = constructor_x64_movups(ctx, &expr1_0)?;
8399                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8400                         return Some(expr3_0);
8401                     }
8402                 }
8403                 _ => {}
8404             }
8405         }
8406         if pattern2_0 == F64X2 {
8407             let pattern4_0 = C::inst_data(ctx, pattern0_0);
8408             match &pattern4_0 {
8409                 &InstructionData::Binary {
8410                     opcode: ref pattern5_0,
8411                     args: ref pattern5_1,
8412                 } => {
8413                     match pattern5_0 {
8414                         &Opcode::Fadd => {
8415                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8416                             // Rule at src/isa/x64/lower.isle line 2275.
8417                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8418                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8419                             let expr2_0 = constructor_x64_addpd(ctx, expr0_0, &expr1_0)?;
8420                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8421                             return Some(expr3_0);
8422                         }
8423                         &Opcode::Fsub => {
8424                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8425                             // Rule at src/isa/x64/lower.isle line 2286.
8426                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8427                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8428                             let expr2_0 = constructor_x64_subpd(ctx, expr0_0, &expr1_0)?;
8429                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8430                             return Some(expr3_0);
8431                         }
8432                         &Opcode::Fmul => {
8433                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8434                             // Rule at src/isa/x64/lower.isle line 2297.
8435                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8436                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8437                             let expr2_0 = constructor_x64_mulpd(ctx, expr0_0, &expr1_0)?;
8438                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8439                             return Some(expr3_0);
8440                         }
8441                         &Opcode::Fdiv => {
8442                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8443                             // Rule at src/isa/x64/lower.isle line 2308.
8444                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8445                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8446                             let expr2_0 = constructor_x64_divpd(ctx, expr0_0, &expr1_0)?;
8447                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8448                             return Some(expr3_0);
8449                         }
8450                         &Opcode::Fmin => {
8451                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8452                             // Rule at src/isa/x64/lower.isle line 2383.
8453                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8454                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8455                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
8456                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8457                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8458                             let expr5_0 = constructor_x64_minpd(ctx, expr3_0, expr4_0)?;
8459                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8460                             let expr7_0 = constructor_x64_orpd(ctx, expr2_0, &expr6_0)?;
8461                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8462                             let expr9_0 = FcmpImm::Unordered;
8463                             let expr10_0 = constructor_x64_cmppd(ctx, expr2_0, &expr8_0, &expr9_0)?;
8464                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
8465                             let expr12_0 = constructor_x64_orpd(ctx, expr7_0, &expr11_0)?;
8466                             let expr13_0: u32 = 13;
8467                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
8468                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
8469                             let expr16_0 = constructor_x64_psrlq(ctx, expr10_0, &expr15_0)?;
8470                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
8471                             let expr18_0 = constructor_x64_andnpd(ctx, expr16_0, &expr17_0)?;
8472                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
8473                             return Some(expr19_0);
8474                         }
8475                         &Opcode::FminPseudo => {
8476                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8477                             // Rule at src/isa/x64/lower.isle line 2498.
8478                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8479                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8480                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
8481                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8482                             return Some(expr3_0);
8483                         }
8484                         &Opcode::Fmax => {
8485                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8486                             // Rule at src/isa/x64/lower.isle line 2446.
8487                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8488                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8489                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
8490                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8491                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8492                             let expr5_0 = constructor_x64_maxpd(ctx, expr3_0, expr4_0)?;
8493                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8494                             let expr7_0 = constructor_x64_xorpd(ctx, expr2_0, &expr6_0)?;
8495                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8496                             let expr9_0 = constructor_x64_orpd(ctx, expr2_0, &expr8_0)?;
8497                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8498                             let expr11_0 = constructor_x64_subpd(ctx, expr9_0, &expr10_0)?;
8499                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
8500                             let expr13_0 = FcmpImm::Unordered;
8501                             let expr14_0 =
8502                                 constructor_x64_cmppd(ctx, expr9_0, &expr12_0, &expr13_0)?;
8503                             let expr15_0: u32 = 13;
8504                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
8505                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
8506                             let expr18_0 = constructor_x64_psrlq(ctx, expr14_0, &expr17_0)?;
8507                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8508                             let expr20_0 = constructor_x64_andnpd(ctx, expr18_0, &expr19_0)?;
8509                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
8510                             return Some(expr21_0);
8511                         }
8512                         &Opcode::FmaxPseudo => {
8513                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8514                             // Rule at src/isa/x64/lower.isle line 2509.
8515                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8516                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8517                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
8518                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8519                             return Some(expr3_0);
8520                         }
8521                         _ => {}
8522                     }
8523                 }
8524                 &InstructionData::Unary {
8525                     opcode: ref pattern5_0,
8526                     arg: pattern5_1,
8527                 } => {
8528                     match pattern5_0 {
8529                         &Opcode::Sqrt => {
8530                             // Rule at src/isa/x64/lower.isle line 2318.
8531                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8532                             let expr1_0 = constructor_x64_sqrtpd(ctx, expr0_0)?;
8533                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8534                             return Some(expr2_0);
8535                         }
8536                         &Opcode::Fabs => {
8537                             // Rule at src/isa/x64/lower.isle line 1244.
8538                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8539                             let expr1_0: Type = F64X2;
8540                             let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
8541                             let expr3_0: u32 = 1;
8542                             let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
8543                             let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
8544                             let expr6_0 = constructor_x64_psrlq(ctx, expr2_0, &expr5_0)?;
8545                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
8546                             let expr8_0 = constructor_x64_andpd(ctx, expr0_0, &expr7_0)?;
8547                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
8548                             return Some(expr9_0);
8549                         }
8550                         _ => {}
8551                     }
8552                 }
8553                 &InstructionData::Load {
8554                     opcode: ref pattern5_0,
8555                     arg: pattern5_1,
8556                     flags: pattern5_2,
8557                     offset: pattern5_3,
8558                 } => {
8559                     if let &Opcode::Load = pattern5_0 {
8560                         // Rule at src/isa/x64/lower.isle line 2552.
8561                         let expr0_0 =
8562                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8563                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8564                         let expr2_0 = constructor_x64_movupd(ctx, &expr1_0)?;
8565                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8566                         return Some(expr3_0);
8567                     }
8568                 }
8569                 _ => {}
8570             }
8571         }
8572         let pattern3_0 = C::inst_data(ctx, pattern0_0);
8573         match &pattern3_0 {
8574             &InstructionData::NullAry {
8575                 opcode: ref pattern4_0,
8576             } => {
8577                 if let &Opcode::Null = pattern4_0 {
8578                     // Rule at src/isa/x64/lower.isle line 56.
8579                     let expr0_0: u64 = 0;
8580                     let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?;
8581                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
8582                     return Some(expr2_0);
8583                 }
8584             }
8585             &InstructionData::Binary {
8586                 opcode: ref pattern4_0,
8587                 args: ref pattern4_1,
8588             } => {
8589                 if let &Opcode::BandNot = pattern4_0 {
8590                     let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
8591                     // Rule at src/isa/x64/lower.isle line 1205.
8592                     let expr0_0 = constructor_put_in_xmm(ctx, pattern6_1)?;
8593                     let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern6_0)?;
8594                     let expr2_0 = constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr1_0)?;
8595                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8596                     return Some(expr3_0);
8597                 }
8598             }
8599             &InstructionData::Ternary {
8600                 opcode: ref pattern4_0,
8601                 args: ref pattern4_1,
8602             } => {
8603                 if let &Opcode::Select = pattern4_0 {
8604                     let (pattern6_0, pattern6_1, pattern6_2) =
8605                         C::unpack_value_array_3(ctx, pattern4_1);
8606                     if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) {
8607                         let pattern8_0 = C::inst_data(ctx, pattern7_0);
8608                         match &pattern8_0 {
8609                             &InstructionData::FloatCompare {
8610                                 opcode: ref pattern9_0,
8611                                 args: ref pattern9_1,
8612                                 cond: ref pattern9_2,
8613                             } => {
8614                                 if let &Opcode::Fcmp = pattern9_0 {
8615                                     let (pattern11_0, pattern11_1) =
8616                                         C::unpack_value_array_2(ctx, pattern9_1);
8617                                     match pattern9_2 {
8618                                         &FloatCC::Equal => {
8619                                             // Rule at src/isa/x64/lower.isle line 1746.
8620                                             let expr0_0 = constructor_x64_ucomis(
8621                                                 ctx,
8622                                                 pattern11_0,
8623                                                 pattern11_1,
8624                                             )?;
8625                                             let expr1_0 = CC::NZ;
8626                                             let expr2_0 = CC::P;
8627                                             let expr3_0 = constructor_cmove_or_from_values(
8628                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_2,
8629                                                 pattern6_1,
8630                                             )?;
8631                                             let expr4_0 =
8632                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
8633                                             let expr5_0 = C::output(ctx, expr4_0);
8634                                             return Some(expr5_0);
8635                                         }
8636                                         &FloatCC::GreaterThan => {
8637                                             // Rule at src/isa/x64/lower.isle line 1698.
8638                                             let expr0_0 = constructor_x64_ucomis(
8639                                                 ctx,
8640                                                 pattern11_1,
8641                                                 pattern11_0,
8642                                             )?;
8643                                             let expr1_0 = CC::NBE;
8644                                             let expr2_0 = constructor_cmove_from_values(
8645                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8646                                             )?;
8647                                             let expr3_0 =
8648                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8649                                             let expr4_0 = C::output(ctx, expr3_0);
8650                                             return Some(expr4_0);
8651                                         }
8652                                         &FloatCC::GreaterThanOrEqual => {
8653                                             // Rule at src/isa/x64/lower.isle line 1701.
8654                                             let expr0_0 = constructor_x64_ucomis(
8655                                                 ctx,
8656                                                 pattern11_1,
8657                                                 pattern11_0,
8658                                             )?;
8659                                             let expr1_0 = CC::NB;
8660                                             let expr2_0 = constructor_cmove_from_values(
8661                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8662                                             )?;
8663                                             let expr3_0 =
8664                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8665                                             let expr4_0 = C::output(ctx, expr3_0);
8666                                             return Some(expr4_0);
8667                                         }
8668                                         &FloatCC::LessThan => {
8669                                             // Rule at src/isa/x64/lower.isle line 1721.
8670                                             let expr0_0 = constructor_x64_ucomis(
8671                                                 ctx,
8672                                                 pattern11_0,
8673                                                 pattern11_1,
8674                                             )?;
8675                                             let expr1_0 = CC::NBE;
8676                                             let expr2_0 = constructor_cmove_from_values(
8677                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8678                                             )?;
8679                                             let expr3_0 =
8680                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8681                                             let expr4_0 = C::output(ctx, expr3_0);
8682                                             return Some(expr4_0);
8683                                         }
8684                                         &FloatCC::LessThanOrEqual => {
8685                                             // Rule at src/isa/x64/lower.isle line 1724.
8686                                             let expr0_0 = constructor_x64_ucomis(
8687                                                 ctx,
8688                                                 pattern11_0,
8689                                                 pattern11_1,
8690                                             )?;
8691                                             let expr1_0 = CC::NB;
8692                                             let expr2_0 = constructor_cmove_from_values(
8693                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8694                                             )?;
8695                                             let expr3_0 =
8696                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8697                                             let expr4_0 = C::output(ctx, expr3_0);
8698                                             return Some(expr4_0);
8699                                         }
8700                                         &FloatCC::NotEqual => {
8701                                             // Rule at src/isa/x64/lower.isle line 1749.
8702                                             let expr0_0 = constructor_x64_ucomis(
8703                                                 ctx,
8704                                                 pattern11_0,
8705                                                 pattern11_1,
8706                                             )?;
8707                                             let expr1_0 = CC::NZ;
8708                                             let expr2_0 = CC::P;
8709                                             let expr3_0 = constructor_cmove_or_from_values(
8710                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_1,
8711                                                 pattern6_2,
8712                                             )?;
8713                                             let expr4_0 =
8714                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
8715                                             let expr5_0 = C::output(ctx, expr4_0);
8716                                             return Some(expr5_0);
8717                                         }
8718                                         &FloatCC::Ordered => {
8719                                             // Rule at src/isa/x64/lower.isle line 1692.
8720                                             let expr0_0 = constructor_x64_ucomis(
8721                                                 ctx,
8722                                                 pattern11_1,
8723                                                 pattern11_0,
8724                                             )?;
8725                                             let expr1_0 = CC::NP;
8726                                             let expr2_0 = constructor_cmove_from_values(
8727                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8728                                             )?;
8729                                             let expr3_0 =
8730                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8731                                             let expr4_0 = C::output(ctx, expr3_0);
8732                                             return Some(expr4_0);
8733                                         }
8734                                         &FloatCC::Unordered => {
8735                                             // Rule at src/isa/x64/lower.isle line 1695.
8736                                             let expr0_0 = constructor_x64_ucomis(
8737                                                 ctx,
8738                                                 pattern11_1,
8739                                                 pattern11_0,
8740                                             )?;
8741                                             let expr1_0 = CC::P;
8742                                             let expr2_0 = constructor_cmove_from_values(
8743                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8744                                             )?;
8745                                             let expr3_0 =
8746                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8747                                             let expr4_0 = C::output(ctx, expr3_0);
8748                                             return Some(expr4_0);
8749                                         }
8750                                         &FloatCC::UnorderedOrGreaterThan => {
8751                                             // Rule at src/isa/x64/lower.isle line 1727.
8752                                             let expr0_0 = constructor_x64_ucomis(
8753                                                 ctx,
8754                                                 pattern11_0,
8755                                                 pattern11_1,
8756                                             )?;
8757                                             let expr1_0 = CC::B;
8758                                             let expr2_0 = constructor_cmove_from_values(
8759                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8760                                             )?;
8761                                             let expr3_0 =
8762                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8763                                             let expr4_0 = C::output(ctx, expr3_0);
8764                                             return Some(expr4_0);
8765                                         }
8766                                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
8767                                             // Rule at src/isa/x64/lower.isle line 1730.
8768                                             let expr0_0 = constructor_x64_ucomis(
8769                                                 ctx,
8770                                                 pattern11_0,
8771                                                 pattern11_1,
8772                                             )?;
8773                                             let expr1_0 = CC::BE;
8774                                             let expr2_0 = constructor_cmove_from_values(
8775                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8776                                             )?;
8777                                             let expr3_0 =
8778                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8779                                             let expr4_0 = C::output(ctx, expr3_0);
8780                                             return Some(expr4_0);
8781                                         }
8782                                         &FloatCC::UnorderedOrLessThan => {
8783                                             // Rule at src/isa/x64/lower.isle line 1704.
8784                                             let expr0_0 = constructor_x64_ucomis(
8785                                                 ctx,
8786                                                 pattern11_1,
8787                                                 pattern11_0,
8788                                             )?;
8789                                             let expr1_0 = CC::B;
8790                                             let expr2_0 = constructor_cmove_from_values(
8791                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8792                                             )?;
8793                                             let expr3_0 =
8794                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8795                                             let expr4_0 = C::output(ctx, expr3_0);
8796                                             return Some(expr4_0);
8797                                         }
8798                                         &FloatCC::UnorderedOrLessThanOrEqual => {
8799                                             // Rule at src/isa/x64/lower.isle line 1707.
8800                                             let expr0_0 = constructor_x64_ucomis(
8801                                                 ctx,
8802                                                 pattern11_1,
8803                                                 pattern11_0,
8804                                             )?;
8805                                             let expr1_0 = CC::BE;
8806                                             let expr2_0 = constructor_cmove_from_values(
8807                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8808                                             )?;
8809                                             let expr3_0 =
8810                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8811                                             let expr4_0 = C::output(ctx, expr3_0);
8812                                             return Some(expr4_0);
8813                                         }
8814                                         _ => {}
8815                                     }
8816                                 }
8817                             }
8818                             &InstructionData::IntCompare {
8819                                 opcode: ref pattern9_0,
8820                                 args: ref pattern9_1,
8821                                 cond: ref pattern9_2,
8822                             } => {
8823                                 if let &Opcode::Icmp = pattern9_0 {
8824                                     let (pattern11_0, pattern11_1) =
8825                                         C::unpack_value_array_2(ctx, pattern9_1);
8826                                     let pattern12_0 = C::value_type(ctx, pattern11_0);
8827                                     if let Some(pattern13_0) = C::fits_in_64(ctx, pattern12_0) {
8828                                         // Rule at src/isa/x64/lower.isle line 1757.
8829                                         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern13_0);
8830                                         let expr1_0 =
8831                                             constructor_put_in_gpr_mem_imm(ctx, pattern11_1)?;
8832                                         let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
8833                                         let expr3_0 =
8834                                             constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?;
8835                                         let expr4_0 = C::intcc_to_cc(ctx, pattern9_2);
8836                                         let expr5_0 = constructor_cmove_from_values(
8837                                             ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2,
8838                                         )?;
8839                                         let expr6_0 =
8840                                             constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
8841                                         let expr7_0 = C::output(ctx, expr6_0);
8842                                         return Some(expr7_0);
8843                                     }
8844                                 }
8845                             }
8846                             _ => {}
8847                         }
8848                     }
8849                     let pattern7_0 = C::value_type(ctx, pattern6_0);
8850                     if pattern7_0 == B1 {
8851                         // Rule at src/isa/x64/lower.isle line 1764.
8852                         let expr0_0: Type = B1;
8853                         let expr1_0 = C::raw_operand_size_of_type(ctx, expr0_0);
8854                         let expr2_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
8855                         let expr3_0: u32 = 1;
8856                         let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
8857                         let expr5_0 = C::gpr_mem_imm_new(ctx, &expr4_0);
8858                         let expr6_0 = constructor_x64_test(ctx, &expr1_0, &expr5_0, expr2_0)?;
8859                         let expr7_0 = CC::NZ;
8860                         let expr8_0 = constructor_cmove_from_values(
8861                             ctx, pattern2_0, &expr7_0, pattern6_1, pattern6_2,
8862                         )?;
8863                         let expr9_0 = constructor_with_flags(ctx, &expr6_0, &expr8_0)?;
8864                         let expr10_0 = C::output(ctx, expr9_0);
8865                         return Some(expr10_0);
8866                     }
8867                     if let Some(pattern8_0) = C::fits_in_64(ctx, pattern7_0) {
8868                         // Rule at src/isa/x64/lower.isle line 1771.
8869                         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern8_0);
8870                         let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
8871                         let expr2_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
8872                         let expr3_0 = constructor_x64_test(ctx, &expr0_0, &expr2_0, expr1_0)?;
8873                         let expr4_0 = CC::NZ;
8874                         let expr5_0 = constructor_cmove_from_values(
8875                             ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2,
8876                         )?;
8877                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
8878                         let expr7_0 = C::output(ctx, expr6_0);
8879                         return Some(expr7_0);
8880                     }
8881                 }
8882             }
8883             &InstructionData::Unary {
8884                 opcode: ref pattern4_0,
8885                 arg: pattern4_1,
8886             } => {
8887                 match pattern4_0 {
8888                     &Opcode::Breduce => {
8889                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8890                         if pattern6_0 == pattern2_0 {
8891                             // Rule at src/isa/x64/lower.isle line 2232.
8892                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8893                             return Some(expr0_0);
8894                         }
8895                     }
8896                     &Opcode::Bextend => {
8897                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8898                         // Rule at src/isa/x64/lower.isle line 2213.
8899                         let expr0_0 =
8900                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
8901                         return Some(expr0_0);
8902                     }
8903                     &Opcode::Ireduce => {
8904                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8905                         if pattern6_0 == pattern2_0 {
8906                             // Rule at src/isa/x64/lower.isle line 2221.
8907                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8908                             return Some(expr0_0);
8909                         }
8910                     }
8911                     &Opcode::Uextend => {
8912                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8913                         if pattern6_0 == pattern2_0 {
8914                             // Rule at src/isa/x64/lower.isle line 2114.
8915                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8916                             return Some(expr0_0);
8917                         }
8918                     }
8919                     &Opcode::Sextend => {
8920                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8921                         // Rule at src/isa/x64/lower.isle line 2207.
8922                         let expr0_0 =
8923                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
8924                         return Some(expr0_0);
8925                     }
8926                     _ => {}
8927                 }
8928             }
8929             _ => {}
8930         }
8931         if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
8932             if let Some(()) = C::avx512dq_enabled(ctx, pattern2_0) {
8933                 if let Some((pattern5_0, pattern5_1)) = C::multi_lane(ctx, pattern2_0) {
8934                     if pattern5_0 == 64 {
8935                         if pattern5_1 == 2 {
8936                             let pattern8_0 = C::inst_data(ctx, pattern0_0);
8937                             if let &InstructionData::Binary {
8938                                 opcode: ref pattern9_0,
8939                                 args: ref pattern9_1,
8940                             } = &pattern8_0
8941                             {
8942                                 if let &Opcode::Imul = pattern9_0 {
8943                                     let (pattern11_0, pattern11_1) =
8944                                         C::unpack_value_array_2(ctx, pattern9_1);
8945                                     // Rule at src/isa/x64/lower.isle line 992.
8946                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern11_0)?;
8947                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern11_1)?;
8948                                     let expr2_0 = constructor_x64_vpmullq(ctx, &expr0_0, expr1_0)?;
8949                                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8950                                     return Some(expr3_0);
8951                                 }
8952                             }
8953                         }
8954                     }
8955                 }
8956             }
8957             if let Some(()) = C::avx512f_enabled(ctx, pattern2_0) {
8958                 if pattern2_0 == I64X2 {
8959                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8960                     if let &InstructionData::Unary {
8961                         opcode: ref pattern7_0,
8962                         arg: pattern7_1,
8963                     } = &pattern6_0
8964                     {
8965                         if let &Opcode::Iabs = pattern7_0 {
8966                             // Rule at src/isa/x64/lower.isle line 1220.
8967                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8968                             let expr1_0 = constructor_x64_vpabsq(ctx, &expr0_0)?;
8969                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8970                             return Some(expr2_0);
8971                         }
8972                     }
8973                 }
8974             }
8975         }
8976         if let Some((pattern3_0, pattern3_1)) = C::multi_lane(ctx, pattern2_0) {
8977             if pattern3_0 == 8 {
8978                 if pattern3_1 == 16 {
8979                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8980                     if let &InstructionData::Binary {
8981                         opcode: ref pattern7_0,
8982                         args: ref pattern7_1,
8983                     } = &pattern6_0
8984                     {
8985                         match pattern7_0 {
8986                             &Opcode::AvgRound => {
8987                                 let (pattern9_0, pattern9_1) =
8988                                     C::unpack_value_array_2(ctx, pattern7_1);
8989                                 // Rule at src/isa/x64/lower.isle line 903.
8990                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8991                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8992                                 let expr2_0 = constructor_x64_pavgb(ctx, expr0_0, &expr1_0)?;
8993                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8994                                 return Some(expr3_0);
8995                             }
8996                             &Opcode::UaddSat => {
8997                                 let (pattern9_0, pattern9_1) =
8998                                     C::unpack_value_array_2(ctx, pattern7_1);
8999                                 // Rule at src/isa/x64/lower.isle line 136.
9000                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9001                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9002                                 let expr2_0 = constructor_x64_paddusb(ctx, expr0_0, &expr1_0)?;
9003                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9004                                 return Some(expr3_0);
9005                             }
9006                             &Opcode::SaddSat => {
9007                                 let (pattern9_0, pattern9_1) =
9008                                     C::unpack_value_array_2(ctx, pattern7_1);
9009                                 // Rule at src/isa/x64/lower.isle line 126.
9010                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9011                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9012                                 let expr2_0 = constructor_x64_paddsb(ctx, expr0_0, &expr1_0)?;
9013                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9014                                 return Some(expr3_0);
9015                             }
9016                             &Opcode::UsubSat => {
9017                                 let (pattern9_0, pattern9_1) =
9018                                     C::unpack_value_array_2(ctx, pattern7_1);
9019                                 // Rule at src/isa/x64/lower.isle line 282.
9020                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9021                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9022                                 let expr2_0 = constructor_x64_psubusb(ctx, expr0_0, &expr1_0)?;
9023                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9024                                 return Some(expr3_0);
9025                             }
9026                             &Opcode::SsubSat => {
9027                                 let (pattern9_0, pattern9_1) =
9028                                     C::unpack_value_array_2(ctx, pattern7_1);
9029                                 // Rule at src/isa/x64/lower.isle line 272.
9030                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9031                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9032                                 let expr2_0 = constructor_x64_psubsb(ctx, expr0_0, &expr1_0)?;
9033                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9034                                 return Some(expr3_0);
9035                             }
9036                             &Opcode::Iadd => {
9037                                 let (pattern9_0, pattern9_1) =
9038                                     C::unpack_value_array_2(ctx, pattern7_1);
9039                                 // Rule at src/isa/x64/lower.isle line 94.
9040                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9041                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9042                                 let expr2_0 = constructor_x64_paddb(ctx, expr0_0, &expr1_0)?;
9043                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9044                                 return Some(expr3_0);
9045                             }
9046                             &Opcode::Isub => {
9047                                 let (pattern9_0, pattern9_1) =
9048                                     C::unpack_value_array_2(ctx, pattern7_1);
9049                                 // Rule at src/isa/x64/lower.isle line 240.
9050                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9051                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9052                                 let expr2_0 = constructor_x64_psubb(ctx, expr0_0, &expr1_0)?;
9053                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9054                                 return Some(expr3_0);
9055                             }
9056                             _ => {}
9057                         }
9058                     }
9059                 }
9060             }
9061             if pattern3_0 == 16 {
9062                 if pattern3_1 == 8 {
9063                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
9064                     if let &InstructionData::Binary {
9065                         opcode: ref pattern7_0,
9066                         args: ref pattern7_1,
9067                     } = &pattern6_0
9068                     {
9069                         match pattern7_0 {
9070                             &Opcode::AvgRound => {
9071                                 let (pattern9_0, pattern9_1) =
9072                                     C::unpack_value_array_2(ctx, pattern7_1);
9073                                 // Rule at src/isa/x64/lower.isle line 907.
9074                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9075                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9076                                 let expr2_0 = constructor_x64_pavgw(ctx, expr0_0, &expr1_0)?;
9077                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9078                                 return Some(expr3_0);
9079                             }
9080                             &Opcode::UaddSat => {
9081                                 let (pattern9_0, pattern9_1) =
9082                                     C::unpack_value_array_2(ctx, pattern7_1);
9083                                 // Rule at src/isa/x64/lower.isle line 140.
9084                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9085                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9086                                 let expr2_0 = constructor_x64_paddusw(ctx, expr0_0, &expr1_0)?;
9087                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9088                                 return Some(expr3_0);
9089                             }
9090                             &Opcode::SaddSat => {
9091                                 let (pattern9_0, pattern9_1) =
9092                                     C::unpack_value_array_2(ctx, pattern7_1);
9093                                 // Rule at src/isa/x64/lower.isle line 130.
9094                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9095                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9096                                 let expr2_0 = constructor_x64_paddsw(ctx, expr0_0, &expr1_0)?;
9097                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9098                                 return Some(expr3_0);
9099                             }
9100                             &Opcode::UsubSat => {
9101                                 let (pattern9_0, pattern9_1) =
9102                                     C::unpack_value_array_2(ctx, pattern7_1);
9103                                 // Rule at src/isa/x64/lower.isle line 286.
9104                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9105                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9106                                 let expr2_0 = constructor_x64_psubusw(ctx, expr0_0, &expr1_0)?;
9107                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9108                                 return Some(expr3_0);
9109                             }
9110                             &Opcode::SsubSat => {
9111                                 let (pattern9_0, pattern9_1) =
9112                                     C::unpack_value_array_2(ctx, pattern7_1);
9113                                 // Rule at src/isa/x64/lower.isle line 276.
9114                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9115                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9116                                 let expr2_0 = constructor_x64_psubsw(ctx, expr0_0, &expr1_0)?;
9117                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9118                                 return Some(expr3_0);
9119                             }
9120                             &Opcode::Iadd => {
9121                                 let (pattern9_0, pattern9_1) =
9122                                     C::unpack_value_array_2(ctx, pattern7_1);
9123                                 // Rule at src/isa/x64/lower.isle line 98.
9124                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9125                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9126                                 let expr2_0 = constructor_x64_paddw(ctx, expr0_0, &expr1_0)?;
9127                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9128                                 return Some(expr3_0);
9129                             }
9130                             &Opcode::Isub => {
9131                                 let (pattern9_0, pattern9_1) =
9132                                     C::unpack_value_array_2(ctx, pattern7_1);
9133                                 // Rule at src/isa/x64/lower.isle line 244.
9134                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9135                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9136                                 let expr2_0 = constructor_x64_psubw(ctx, expr0_0, &expr1_0)?;
9137                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9138                                 return Some(expr3_0);
9139                             }
9140                             &Opcode::Imul => {
9141                                 let (pattern9_0, pattern9_1) =
9142                                     C::unpack_value_array_2(ctx, pattern7_1);
9143                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
9144                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
9145                                     if let &InstructionData::Unary {
9146                                         opcode: ref pattern12_0,
9147                                         arg: pattern12_1,
9148                                     } = &pattern11_0
9149                                     {
9150                                         match pattern12_0 {
9151                                             &Opcode::SwidenLow => {
9152                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9153                                                 if let Some((pattern15_0, pattern15_1)) =
9154                                                     C::multi_lane(ctx, pattern14_0)
9155                                                 {
9156                                                     if pattern15_0 == 8 {
9157                                                         if pattern15_1 == 16 {
9158                                                             if let Some(pattern18_0) =
9159                                                                 C::def_inst(ctx, pattern9_1)
9160                                                             {
9161                                                                 let pattern19_0 =
9162                                                                     C::inst_data(ctx, pattern18_0);
9163                                                                 if let &InstructionData::Unary {
9164                                                                     opcode: ref pattern20_0,
9165                                                                     arg: pattern20_1,
9166                                                                 } = &pattern19_0
9167                                                                 {
9168                                                                     if let &Opcode::SwidenLow =
9169                                                                         pattern20_0
9170                                                                     {
9171                                                                         let pattern22_0 =
9172                                                                             C::value_type(
9173                                                                                 ctx,
9174                                                                                 pattern20_1,
9175                                                                             );
9176                                                                         if let Some((
9177                                                                             pattern23_0,
9178                                                                             pattern23_1,
9179                                                                         )) = C::multi_lane(
9180                                                                             ctx,
9181                                                                             pattern22_0,
9182                                                                         ) {
9183                                                                             if pattern23_0 == 8 {
9184                                                                                 if pattern23_1 == 16
9185                                                                                 {
9186                                                                                     // Rule at src/isa/x64/lower.isle line 1080.
9187                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9188                                                                                     let expr1_0 = constructor_x64_pmovsxbw(ctx, &expr0_0)?;
9189                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9190                                                                                     let expr3_0 = constructor_x64_pmovsxbw(ctx, &expr2_0)?;
9191                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
9192                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
9193                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
9194                                                                                     return Some(
9195                                                                                         expr6_0,
9196                                                                                     );
9197                                                                                 }
9198                                                                             }
9199                                                                         }
9200                                                                     }
9201                                                                 }
9202                                                             }
9203                                                         }
9204                                                     }
9205                                                 }
9206                                             }
9207                                             &Opcode::SwidenHigh => {
9208                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9209                                                 if let Some((pattern15_0, pattern15_1)) =
9210                                                     C::multi_lane(ctx, pattern14_0)
9211                                                 {
9212                                                     if pattern15_0 == 8 {
9213                                                         if pattern15_1 == 16 {
9214                                                             if let Some(pattern18_0) =
9215                                                                 C::def_inst(ctx, pattern9_1)
9216                                                             {
9217                                                                 let pattern19_0 =
9218                                                                     C::inst_data(ctx, pattern18_0);
9219                                                                 if let &InstructionData::Unary {
9220                                                                     opcode: ref pattern20_0,
9221                                                                     arg: pattern20_1,
9222                                                                 } = &pattern19_0
9223                                                                 {
9224                                                                     if let &Opcode::SwidenHigh =
9225                                                                         pattern20_0
9226                                                                     {
9227                                                                         let pattern22_0 =
9228                                                                             C::value_type(
9229                                                                                 ctx,
9230                                                                                 pattern20_1,
9231                                                                             );
9232                                                                         if let Some((
9233                                                                             pattern23_0,
9234                                                                             pattern23_1,
9235                                                                         )) = C::multi_lane(
9236                                                                             ctx,
9237                                                                             pattern22_0,
9238                                                                         ) {
9239                                                                             if pattern23_0 == 8 {
9240                                                                                 if pattern23_1 == 16
9241                                                                                 {
9242                                                                                     // Rule at src/isa/x64/lower.isle line 1040.
9243                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9244                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
9245                                                                                     let expr2_0: u8 = 8;
9246                                                                                     let expr3_0 = OperandSize::Size32;
9247                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
9248                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
9249                                                                                     let expr6_0 = constructor_x64_pmovsxbw(ctx, &expr5_0)?;
9250                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9251                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9252                                                                                     let expr9_0: u8 = 8;
9253                                                                                     let expr10_0 = OperandSize::Size32;
9254                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
9255                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
9256                                                                                     let expr13_0 = constructor_x64_pmovsxbw(ctx, &expr12_0)?;
9257                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
9258                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
9259                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
9260                                                                                     return Some(
9261                                                                                         expr16_0,
9262                                                                                     );
9263                                                                                 }
9264                                                                             }
9265                                                                         }
9266                                                                     }
9267                                                                 }
9268                                                             }
9269                                                         }
9270                                                     }
9271                                                 }
9272                                             }
9273                                             &Opcode::UwidenLow => {
9274                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9275                                                 if let Some((pattern15_0, pattern15_1)) =
9276                                                     C::multi_lane(ctx, pattern14_0)
9277                                                 {
9278                                                     if pattern15_0 == 8 {
9279                                                         if pattern15_1 == 16 {
9280                                                             if let Some(pattern18_0) =
9281                                                                 C::def_inst(ctx, pattern9_1)
9282                                                             {
9283                                                                 let pattern19_0 =
9284                                                                     C::inst_data(ctx, pattern18_0);
9285                                                                 if let &InstructionData::Unary {
9286                                                                     opcode: ref pattern20_0,
9287                                                                     arg: pattern20_1,
9288                                                                 } = &pattern19_0
9289                                                                 {
9290                                                                     if let &Opcode::UwidenLow =
9291                                                                         pattern20_0
9292                                                                     {
9293                                                                         let pattern22_0 =
9294                                                                             C::value_type(
9295                                                                                 ctx,
9296                                                                                 pattern20_1,
9297                                                                             );
9298                                                                         if let Some((
9299                                                                             pattern23_0,
9300                                                                             pattern23_1,
9301                                                                         )) = C::multi_lane(
9302                                                                             ctx,
9303                                                                             pattern22_0,
9304                                                                         ) {
9305                                                                             if pattern23_0 == 8 {
9306                                                                                 if pattern23_1 == 16
9307                                                                                 {
9308                                                                                     // Rule at src/isa/x64/lower.isle line 1156.
9309                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9310                                                                                     let expr1_0 = constructor_x64_pmovzxbw(ctx, &expr0_0)?;
9311                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9312                                                                                     let expr3_0 = constructor_x64_pmovzxbw(ctx, &expr2_0)?;
9313                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
9314                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
9315                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
9316                                                                                     return Some(
9317                                                                                         expr6_0,
9318                                                                                     );
9319                                                                                 }
9320                                                                             }
9321                                                                         }
9322                                                                     }
9323                                                                 }
9324                                                             }
9325                                                         }
9326                                                     }
9327                                                 }
9328                                             }
9329                                             &Opcode::UwidenHigh => {
9330                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9331                                                 if let Some((pattern15_0, pattern15_1)) =
9332                                                     C::multi_lane(ctx, pattern14_0)
9333                                                 {
9334                                                     if pattern15_0 == 8 {
9335                                                         if pattern15_1 == 16 {
9336                                                             if let Some(pattern18_0) =
9337                                                                 C::def_inst(ctx, pattern9_1)
9338                                                             {
9339                                                                 let pattern19_0 =
9340                                                                     C::inst_data(ctx, pattern18_0);
9341                                                                 if let &InstructionData::Unary {
9342                                                                     opcode: ref pattern20_0,
9343                                                                     arg: pattern20_1,
9344                                                                 } = &pattern19_0
9345                                                                 {
9346                                                                     if let &Opcode::UwidenHigh =
9347                                                                         pattern20_0
9348                                                                     {
9349                                                                         let pattern22_0 =
9350                                                                             C::value_type(
9351                                                                                 ctx,
9352                                                                                 pattern20_1,
9353                                                                             );
9354                                                                         if let Some((
9355                                                                             pattern23_0,
9356                                                                             pattern23_1,
9357                                                                         )) = C::multi_lane(
9358                                                                             ctx,
9359                                                                             pattern22_0,
9360                                                                         ) {
9361                                                                             if pattern23_0 == 8 {
9362                                                                                 if pattern23_1 == 16
9363                                                                                 {
9364                                                                                     // Rule at src/isa/x64/lower.isle line 1116.
9365                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9366                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
9367                                                                                     let expr2_0: u8 = 8;
9368                                                                                     let expr3_0 = OperandSize::Size32;
9369                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
9370                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
9371                                                                                     let expr6_0 = constructor_x64_pmovzxbw(ctx, &expr5_0)?;
9372                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9373                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9374                                                                                     let expr9_0: u8 = 8;
9375                                                                                     let expr10_0 = OperandSize::Size32;
9376                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
9377                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
9378                                                                                     let expr13_0 = constructor_x64_pmovzxbw(ctx, &expr12_0)?;
9379                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
9380                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
9381                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
9382                                                                                     return Some(
9383                                                                                         expr16_0,
9384                                                                                     );
9385                                                                                 }
9386                                                                             }
9387                                                                         }
9388                                                                     }
9389                                                                 }
9390                                                             }
9391                                                         }
9392                                                     }
9393                                                 }
9394                                             }
9395                                             _ => {}
9396                                         }
9397                                     }
9398                                 }
9399                                 // Rule at src/isa/x64/lower.isle line 984.
9400                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9401                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9402                                 let expr2_0 = constructor_x64_pmullw(ctx, expr0_0, &expr1_0)?;
9403                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9404                                 return Some(expr3_0);
9405                             }
9406                             _ => {}
9407                         }
9408                     }
9409                 }
9410             }
9411             if pattern3_0 == 32 {
9412                 if pattern3_1 == 4 {
9413                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
9414                     if let &InstructionData::Binary {
9415                         opcode: ref pattern7_0,
9416                         args: ref pattern7_1,
9417                     } = &pattern6_0
9418                     {
9419                         match pattern7_0 {
9420                             &Opcode::Iadd => {
9421                                 let (pattern9_0, pattern9_1) =
9422                                     C::unpack_value_array_2(ctx, pattern7_1);
9423                                 // Rule at src/isa/x64/lower.isle line 102.
9424                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9425                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9426                                 let expr2_0 = constructor_x64_paddd(ctx, expr0_0, &expr1_0)?;
9427                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9428                                 return Some(expr3_0);
9429                             }
9430                             &Opcode::Isub => {
9431                                 let (pattern9_0, pattern9_1) =
9432                                     C::unpack_value_array_2(ctx, pattern7_1);
9433                                 // Rule at src/isa/x64/lower.isle line 248.
9434                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9435                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9436                                 let expr2_0 = constructor_x64_psubd(ctx, expr0_0, &expr1_0)?;
9437                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9438                                 return Some(expr3_0);
9439                             }
9440                             &Opcode::Imul => {
9441                                 let (pattern9_0, pattern9_1) =
9442                                     C::unpack_value_array_2(ctx, pattern7_1);
9443                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
9444                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
9445                                     if let &InstructionData::Unary {
9446                                         opcode: ref pattern12_0,
9447                                         arg: pattern12_1,
9448                                     } = &pattern11_0
9449                                     {
9450                                         match pattern12_0 {
9451                                             &Opcode::SwidenLow => {
9452                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9453                                                 if let Some((pattern15_0, pattern15_1)) =
9454                                                     C::multi_lane(ctx, pattern14_0)
9455                                                 {
9456                                                     if pattern15_0 == 16 {
9457                                                         if pattern15_1 == 8 {
9458                                                             if let Some(pattern18_0) =
9459                                                                 C::def_inst(ctx, pattern9_1)
9460                                                             {
9461                                                                 let pattern19_0 =
9462                                                                     C::inst_data(ctx, pattern18_0);
9463                                                                 if let &InstructionData::Unary {
9464                                                                     opcode: ref pattern20_0,
9465                                                                     arg: pattern20_1,
9466                                                                 } = &pattern19_0
9467                                                                 {
9468                                                                     if let &Opcode::SwidenLow =
9469                                                                         pattern20_0
9470                                                                     {
9471                                                                         let pattern22_0 =
9472                                                                             C::value_type(
9473                                                                                 ctx,
9474                                                                                 pattern20_1,
9475                                                                             );
9476                                                                         if let Some((
9477                                                                             pattern23_0,
9478                                                                             pattern23_1,
9479                                                                         )) = C::multi_lane(
9480                                                                             ctx,
9481                                                                             pattern22_0,
9482                                                                         ) {
9483                                                                             if pattern23_0 == 16 {
9484                                                                                 if pattern23_1 == 8
9485                                                                                 {
9486                                                                                     // Rule at src/isa/x64/lower.isle line 1090.
9487                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9488                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9489                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9490                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
9491                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9492                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
9493                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
9494                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
9495                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9496                                                                                     return Some(
9497                                                                                         expr8_0,
9498                                                                                     );
9499                                                                                 }
9500                                                                             }
9501                                                                         }
9502                                                                     }
9503                                                                 }
9504                                                             }
9505                                                         }
9506                                                     }
9507                                                 }
9508                                             }
9509                                             &Opcode::SwidenHigh => {
9510                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9511                                                 if let Some((pattern15_0, pattern15_1)) =
9512                                                     C::multi_lane(ctx, pattern14_0)
9513                                                 {
9514                                                     if pattern15_0 == 16 {
9515                                                         if pattern15_1 == 8 {
9516                                                             if let Some(pattern18_0) =
9517                                                                 C::def_inst(ctx, pattern9_1)
9518                                                             {
9519                                                                 let pattern19_0 =
9520                                                                     C::inst_data(ctx, pattern18_0);
9521                                                                 if let &InstructionData::Unary {
9522                                                                     opcode: ref pattern20_0,
9523                                                                     arg: pattern20_1,
9524                                                                 } = &pattern19_0
9525                                                                 {
9526                                                                     if let &Opcode::SwidenHigh =
9527                                                                         pattern20_0
9528                                                                     {
9529                                                                         let pattern22_0 =
9530                                                                             C::value_type(
9531                                                                                 ctx,
9532                                                                                 pattern20_1,
9533                                                                             );
9534                                                                         if let Some((
9535                                                                             pattern23_0,
9536                                                                             pattern23_1,
9537                                                                         )) = C::multi_lane(
9538                                                                             ctx,
9539                                                                             pattern22_0,
9540                                                                         ) {
9541                                                                             if pattern23_0 == 16 {
9542                                                                                 if pattern23_1 == 8
9543                                                                                 {
9544                                                                                     // Rule at src/isa/x64/lower.isle line 1054.
9545                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9546                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9547                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9548                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
9549                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9550                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
9551                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
9552                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
9553                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9554                                                                                     return Some(
9555                                                                                         expr8_0,
9556                                                                                     );
9557                                                                                 }
9558                                                                             }
9559                                                                         }
9560                                                                     }
9561                                                                 }
9562                                                             }
9563                                                         }
9564                                                     }
9565                                                 }
9566                                             }
9567                                             &Opcode::UwidenLow => {
9568                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9569                                                 if let Some((pattern15_0, pattern15_1)) =
9570                                                     C::multi_lane(ctx, pattern14_0)
9571                                                 {
9572                                                     if pattern15_0 == 16 {
9573                                                         if pattern15_1 == 8 {
9574                                                             if let Some(pattern18_0) =
9575                                                                 C::def_inst(ctx, pattern9_1)
9576                                                             {
9577                                                                 let pattern19_0 =
9578                                                                     C::inst_data(ctx, pattern18_0);
9579                                                                 if let &InstructionData::Unary {
9580                                                                     opcode: ref pattern20_0,
9581                                                                     arg: pattern20_1,
9582                                                                 } = &pattern19_0
9583                                                                 {
9584                                                                     if let &Opcode::UwidenLow =
9585                                                                         pattern20_0
9586                                                                     {
9587                                                                         let pattern22_0 =
9588                                                                             C::value_type(
9589                                                                                 ctx,
9590                                                                                 pattern20_1,
9591                                                                             );
9592                                                                         if let Some((
9593                                                                             pattern23_0,
9594                                                                             pattern23_1,
9595                                                                         )) = C::multi_lane(
9596                                                                             ctx,
9597                                                                             pattern22_0,
9598                                                                         ) {
9599                                                                             if pattern23_0 == 16 {
9600                                                                                 if pattern23_1 == 8
9601                                                                                 {
9602                                                                                     // Rule at src/isa/x64/lower.isle line 1166.
9603                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9604                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9605                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9606                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
9607                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9608                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
9609                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
9610                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
9611                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9612                                                                                     return Some(
9613                                                                                         expr8_0,
9614                                                                                     );
9615                                                                                 }
9616                                                                             }
9617                                                                         }
9618                                                                     }
9619                                                                 }
9620                                                             }
9621                                                         }
9622                                                     }
9623                                                 }
9624                                             }
9625                                             &Opcode::UwidenHigh => {
9626                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9627                                                 if let Some((pattern15_0, pattern15_1)) =
9628                                                     C::multi_lane(ctx, pattern14_0)
9629                                                 {
9630                                                     if pattern15_0 == 16 {
9631                                                         if pattern15_1 == 8 {
9632                                                             if let Some(pattern18_0) =
9633                                                                 C::def_inst(ctx, pattern9_1)
9634                                                             {
9635                                                                 let pattern19_0 =
9636                                                                     C::inst_data(ctx, pattern18_0);
9637                                                                 if let &InstructionData::Unary {
9638                                                                     opcode: ref pattern20_0,
9639                                                                     arg: pattern20_1,
9640                                                                 } = &pattern19_0
9641                                                                 {
9642                                                                     if let &Opcode::UwidenHigh =
9643                                                                         pattern20_0
9644                                                                     {
9645                                                                         let pattern22_0 =
9646                                                                             C::value_type(
9647                                                                                 ctx,
9648                                                                                 pattern20_1,
9649                                                                             );
9650                                                                         if let Some((
9651                                                                             pattern23_0,
9652                                                                             pattern23_1,
9653                                                                         )) = C::multi_lane(
9654                                                                             ctx,
9655                                                                             pattern22_0,
9656                                                                         ) {
9657                                                                             if pattern23_0 == 16 {
9658                                                                                 if pattern23_1 == 8
9659                                                                                 {
9660                                                                                     // Rule at src/isa/x64/lower.isle line 1130.
9661                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9662                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9663                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9664                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
9665                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9666                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
9667                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
9668                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
9669                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9670                                                                                     return Some(
9671                                                                                         expr8_0,
9672                                                                                     );
9673                                                                                 }
9674                                                                             }
9675                                                                         }
9676                                                                     }
9677                                                                 }
9678                                                             }
9679                                                         }
9680                                                     }
9681                                                 }
9682                                             }
9683                                             _ => {}
9684                                         }
9685                                     }
9686                                 }
9687                                 // Rule at src/isa/x64/lower.isle line 987.
9688                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9689                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9690                                 let expr2_0 = constructor_x64_pmulld(ctx, expr0_0, &expr1_0)?;
9691                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9692                                 return Some(expr3_0);
9693                             }
9694                             _ => {}
9695                         }
9696                     }
9697                 }
9698             }
9699             if pattern3_0 == 64 {
9700                 if pattern3_1 == 2 {
9701                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
9702                     if let &InstructionData::Binary {
9703                         opcode: ref pattern7_0,
9704                         args: ref pattern7_1,
9705                     } = &pattern6_0
9706                     {
9707                         match pattern7_0 {
9708                             &Opcode::Iadd => {
9709                                 let (pattern9_0, pattern9_1) =
9710                                     C::unpack_value_array_2(ctx, pattern7_1);
9711                                 // Rule at src/isa/x64/lower.isle line 106.
9712                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9713                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9714                                 let expr2_0 = constructor_x64_paddq(ctx, expr0_0, &expr1_0)?;
9715                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9716                                 return Some(expr3_0);
9717                             }
9718                             &Opcode::Isub => {
9719                                 let (pattern9_0, pattern9_1) =
9720                                     C::unpack_value_array_2(ctx, pattern7_1);
9721                                 // Rule at src/isa/x64/lower.isle line 252.
9722                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9723                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9724                                 let expr2_0 = constructor_x64_psubq(ctx, expr0_0, &expr1_0)?;
9725                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9726                                 return Some(expr3_0);
9727                             }
9728                             &Opcode::Imul => {
9729                                 let (pattern9_0, pattern9_1) =
9730                                     C::unpack_value_array_2(ctx, pattern7_1);
9731                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
9732                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
9733                                     if let &InstructionData::Unary {
9734                                         opcode: ref pattern12_0,
9735                                         arg: pattern12_1,
9736                                     } = &pattern11_0
9737                                     {
9738                                         match pattern12_0 {
9739                                             &Opcode::SwidenLow => {
9740                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9741                                                 if let Some((pattern15_0, pattern15_1)) =
9742                                                     C::multi_lane(ctx, pattern14_0)
9743                                                 {
9744                                                     if pattern15_0 == 32 {
9745                                                         if pattern15_1 == 4 {
9746                                                             if let Some(pattern18_0) =
9747                                                                 C::def_inst(ctx, pattern9_1)
9748                                                             {
9749                                                                 let pattern19_0 =
9750                                                                     C::inst_data(ctx, pattern18_0);
9751                                                                 if let &InstructionData::Unary {
9752                                                                     opcode: ref pattern20_0,
9753                                                                     arg: pattern20_1,
9754                                                                 } = &pattern19_0
9755                                                                 {
9756                                                                     if let &Opcode::SwidenLow =
9757                                                                         pattern20_0
9758                                                                     {
9759                                                                         let pattern22_0 =
9760                                                                             C::value_type(
9761                                                                                 ctx,
9762                                                                                 pattern20_1,
9763                                                                             );
9764                                                                         if let Some((
9765                                                                             pattern23_0,
9766                                                                             pattern23_1,
9767                                                                         )) = C::multi_lane(
9768                                                                             ctx,
9769                                                                             pattern22_0,
9770                                                                         ) {
9771                                                                             if pattern23_0 == 32 {
9772                                                                                 if pattern23_1 == 4
9773                                                                                 {
9774                                                                                     // Rule at src/isa/x64/lower.isle line 1102.
9775                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9776                                                                                     let expr1_0: u8 = 80;
9777                                                                                     let expr2_0 = OperandSize::Size32;
9778                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9779                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9780                                                                                     let expr5_0: u8 = 80;
9781                                                                                     let expr6_0 = OperandSize::Size32;
9782                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9783                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9784                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
9785                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9786                                                                                     return Some(
9787                                                                                         expr10_0,
9788                                                                                     );
9789                                                                                 }
9790                                                                             }
9791                                                                         }
9792                                                                     }
9793                                                                 }
9794                                                             }
9795                                                         }
9796                                                     }
9797                                                 }
9798                                             }
9799                                             &Opcode::SwidenHigh => {
9800                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9801                                                 if let Some((pattern15_0, pattern15_1)) =
9802                                                     C::multi_lane(ctx, pattern14_0)
9803                                                 {
9804                                                     if pattern15_0 == 32 {
9805                                                         if pattern15_1 == 4 {
9806                                                             if let Some(pattern18_0) =
9807                                                                 C::def_inst(ctx, pattern9_1)
9808                                                             {
9809                                                                 let pattern19_0 =
9810                                                                     C::inst_data(ctx, pattern18_0);
9811                                                                 if let &InstructionData::Unary {
9812                                                                     opcode: ref pattern20_0,
9813                                                                     arg: pattern20_1,
9814                                                                 } = &pattern19_0
9815                                                                 {
9816                                                                     if let &Opcode::SwidenHigh =
9817                                                                         pattern20_0
9818                                                                     {
9819                                                                         let pattern22_0 =
9820                                                                             C::value_type(
9821                                                                                 ctx,
9822                                                                                 pattern20_1,
9823                                                                             );
9824                                                                         if let Some((
9825                                                                             pattern23_0,
9826                                                                             pattern23_1,
9827                                                                         )) = C::multi_lane(
9828                                                                             ctx,
9829                                                                             pattern22_0,
9830                                                                         ) {
9831                                                                             if pattern23_0 == 32 {
9832                                                                                 if pattern23_1 == 4
9833                                                                                 {
9834                                                                                     // Rule at src/isa/x64/lower.isle line 1066.
9835                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9836                                                                                     let expr1_0: u8 = 250;
9837                                                                                     let expr2_0 = OperandSize::Size32;
9838                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9839                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9840                                                                                     let expr5_0: u8 = 250;
9841                                                                                     let expr6_0 = OperandSize::Size32;
9842                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9843                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9844                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
9845                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9846                                                                                     return Some(
9847                                                                                         expr10_0,
9848                                                                                     );
9849                                                                                 }
9850                                                                             }
9851                                                                         }
9852                                                                     }
9853                                                                 }
9854                                                             }
9855                                                         }
9856                                                     }
9857                                                 }
9858                                             }
9859                                             &Opcode::UwidenLow => {
9860                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9861                                                 if let Some((pattern15_0, pattern15_1)) =
9862                                                     C::multi_lane(ctx, pattern14_0)
9863                                                 {
9864                                                     if pattern15_0 == 32 {
9865                                                         if pattern15_1 == 4 {
9866                                                             if let Some(pattern18_0) =
9867                                                                 C::def_inst(ctx, pattern9_1)
9868                                                             {
9869                                                                 let pattern19_0 =
9870                                                                     C::inst_data(ctx, pattern18_0);
9871                                                                 if let &InstructionData::Unary {
9872                                                                     opcode: ref pattern20_0,
9873                                                                     arg: pattern20_1,
9874                                                                 } = &pattern19_0
9875                                                                 {
9876                                                                     if let &Opcode::UwidenLow =
9877                                                                         pattern20_0
9878                                                                     {
9879                                                                         let pattern22_0 =
9880                                                                             C::value_type(
9881                                                                                 ctx,
9882                                                                                 pattern20_1,
9883                                                                             );
9884                                                                         if let Some((
9885                                                                             pattern23_0,
9886                                                                             pattern23_1,
9887                                                                         )) = C::multi_lane(
9888                                                                             ctx,
9889                                                                             pattern22_0,
9890                                                                         ) {
9891                                                                             if pattern23_0 == 32 {
9892                                                                                 if pattern23_1 == 4
9893                                                                                 {
9894                                                                                     // Rule at src/isa/x64/lower.isle line 1178.
9895                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9896                                                                                     let expr1_0: u8 = 80;
9897                                                                                     let expr2_0 = OperandSize::Size32;
9898                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9899                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9900                                                                                     let expr5_0: u8 = 80;
9901                                                                                     let expr6_0 = OperandSize::Size32;
9902                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9903                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9904                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
9905                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9906                                                                                     return Some(
9907                                                                                         expr10_0,
9908                                                                                     );
9909                                                                                 }
9910                                                                             }
9911                                                                         }
9912                                                                     }
9913                                                                 }
9914                                                             }
9915                                                         }
9916                                                     }
9917                                                 }
9918                                             }
9919                                             &Opcode::UwidenHigh => {
9920                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9921                                                 if let Some((pattern15_0, pattern15_1)) =
9922                                                     C::multi_lane(ctx, pattern14_0)
9923                                                 {
9924                                                     if pattern15_0 == 32 {
9925                                                         if pattern15_1 == 4 {
9926                                                             if let Some(pattern18_0) =
9927                                                                 C::def_inst(ctx, pattern9_1)
9928                                                             {
9929                                                                 let pattern19_0 =
9930                                                                     C::inst_data(ctx, pattern18_0);
9931                                                                 if let &InstructionData::Unary {
9932                                                                     opcode: ref pattern20_0,
9933                                                                     arg: pattern20_1,
9934                                                                 } = &pattern19_0
9935                                                                 {
9936                                                                     if let &Opcode::UwidenHigh =
9937                                                                         pattern20_0
9938                                                                     {
9939                                                                         let pattern22_0 =
9940                                                                             C::value_type(
9941                                                                                 ctx,
9942                                                                                 pattern20_1,
9943                                                                             );
9944                                                                         if let Some((
9945                                                                             pattern23_0,
9946                                                                             pattern23_1,
9947                                                                         )) = C::multi_lane(
9948                                                                             ctx,
9949                                                                             pattern22_0,
9950                                                                         ) {
9951                                                                             if pattern23_0 == 32 {
9952                                                                                 if pattern23_1 == 4
9953                                                                                 {
9954                                                                                     // Rule at src/isa/x64/lower.isle line 1142.
9955                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9956                                                                                     let expr1_0: u8 = 250;
9957                                                                                     let expr2_0 = OperandSize::Size32;
9958                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9959                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9960                                                                                     let expr5_0: u8 = 250;
9961                                                                                     let expr6_0 = OperandSize::Size32;
9962                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9963                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9964                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
9965                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9966                                                                                     return Some(
9967                                                                                         expr10_0,
9968                                                                                     );
9969                                                                                 }
9970                                                                             }
9971                                                                         }
9972                                                                     }
9973                                                                 }
9974                                                             }
9975                                                         }
9976                                                     }
9977                                                 }
9978                                             }
9979                                             _ => {}
9980                                         }
9981                                     }
9982                                 }
9983                                 // Rule at src/isa/x64/lower.isle line 1018.
9984                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9985                                 let expr1_0 = constructor_put_in_xmm(ctx, pattern9_1)?;
9986                                 let expr2_0: u32 = 32;
9987                                 let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
9988                                 let expr4_0 = constructor_mov_rmi_to_xmm(ctx, &expr3_0)?;
9989                                 let expr5_0 = constructor_x64_psrlq(ctx, expr0_0, &expr4_0)?;
9990                                 let expr6_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9991                                 let expr7_0 = constructor_x64_pmuludq(ctx, expr5_0, &expr6_0)?;
9992                                 let expr8_0: u32 = 32;
9993                                 let expr9_0 = RegMemImm::Imm { simm32: expr8_0 };
9994                                 let expr10_0 = constructor_mov_rmi_to_xmm(ctx, &expr9_0)?;
9995                                 let expr11_0 = constructor_x64_psrlq(ctx, expr1_0, &expr10_0)?;
9996                                 let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
9997                                 let expr13_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr12_0)?;
9998                                 let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
9999                                 let expr15_0 = constructor_x64_paddq(ctx, expr7_0, &expr14_0)?;
10000                                 let expr16_0: u32 = 32;
10001                                 let expr17_0 = RegMemImm::Imm { simm32: expr16_0 };
10002                                 let expr18_0 = constructor_mov_rmi_to_xmm(ctx, &expr17_0)?;
10003                                 let expr19_0 = constructor_x64_psllq(ctx, expr15_0, &expr18_0)?;
10004                                 let expr20_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
10005                                 let expr21_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr20_0)?;
10006                                 let expr22_0 = C::xmm_to_xmm_mem(ctx, expr19_0);
10007                                 let expr23_0 = constructor_x64_paddq(ctx, expr21_0, &expr22_0)?;
10008                                 let expr24_0 = constructor_output_xmm(ctx, expr23_0)?;
10009                                 return Some(expr24_0);
10010                             }
10011                             _ => {}
10012                         }
10013                     }
10014                 }
10015             }
10016             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10017             match &pattern4_0 {
10018                 &InstructionData::Binary {
10019                     opcode: ref pattern5_0,
10020                     args: ref pattern5_1,
10021                 } => {
10022                     match pattern5_0 {
10023                         &Opcode::Band => {
10024                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10025                             // Rule at src/isa/x64/lower.isle line 328.
10026                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
10027                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
10028                             let expr2_0 = constructor_sse_and(ctx, pattern2_0, expr0_0, &expr1_0)?;
10029                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10030                             return Some(expr3_0);
10031                         }
10032                         &Opcode::Bor => {
10033                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10034                             // Rule at src/isa/x64/lower.isle line 392.
10035                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
10036                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
10037                             let expr2_0 = constructor_sse_or(ctx, pattern2_0, expr0_0, &expr1_0)?;
10038                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10039                             return Some(expr3_0);
10040                         }
10041                         &Opcode::Bxor => {
10042                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10043                             // Rule at src/isa/x64/lower.isle line 453.
10044                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
10045                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
10046                             let expr2_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr1_0)?;
10047                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10048                             return Some(expr3_0);
10049                         }
10050                         _ => {}
10051                     }
10052                 }
10053                 &InstructionData::Ternary {
10054                     opcode: ref pattern5_0,
10055                     args: ref pattern5_1,
10056                 } => {
10057                     match pattern5_0 {
10058                         &Opcode::Bitselect => {
10059                             let (pattern7_0, pattern7_1, pattern7_2) =
10060                                 C::unpack_value_array_3(ctx, pattern5_1);
10061                             // Rule at src/isa/x64/lower.isle line 1279.
10062                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
10063                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
10064                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
10065                             let expr3_0 = constructor_sse_and(ctx, pattern2_0, expr1_0, &expr2_0)?;
10066                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern7_2)?;
10067                             let expr5_0 =
10068                                 constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr4_0)?;
10069                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
10070                             let expr7_0 = constructor_sse_or(ctx, pattern2_0, expr5_0, &expr6_0)?;
10071                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
10072                             return Some(expr8_0);
10073                         }
10074                         &Opcode::Vselect => {
10075                             let (pattern7_0, pattern7_1, pattern7_2) =
10076                                 C::unpack_value_array_3(ctx, pattern5_1);
10077                             // Rule at src/isa/x64/lower.isle line 1293.
10078                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_0)?;
10079                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
10080                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_2)?;
10081                             let expr3_0 = constructor_x64_blend(
10082                                 ctx, pattern2_0, &expr0_0, &expr1_0, expr2_0,
10083                             )?;
10084                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
10085                             return Some(expr4_0);
10086                         }
10087                         _ => {}
10088                     }
10089                 }
10090                 &InstructionData::Unary {
10091                     opcode: ref pattern5_0,
10092                     arg: pattern5_1,
10093                 } => {
10094                     if let &Opcode::Bnot = pattern5_0 {
10095                         // Rule at src/isa/x64/lower.isle line 1274.
10096                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
10097                         let expr1_0 = constructor_vector_all_ones(ctx, pattern2_0)?;
10098                         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
10099                         let expr3_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr2_0)?;
10100                         let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
10101                         return Some(expr4_0);
10102                     }
10103                 }
10104                 _ => {}
10105             }
10106         }
10107         if let Some(pattern3_0) = C::fits_in_32(ctx, pattern2_0) {
10108             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10109             if let &InstructionData::Unary {
10110                 opcode: ref pattern5_0,
10111                 arg: pattern5_1,
10112             } = &pattern4_0
10113             {
10114                 if let &Opcode::Uextend = pattern5_0 {
10115                     let pattern7_0 = C::value_type(ctx, pattern5_1);
10116                     if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
10117                         // Rule at src/isa/x64/lower.isle line 2130.
10118                         let expr0_0: Type = I32;
10119                         let expr1_0 = ExtendKind::Zero;
10120                         let expr2_0 =
10121                             constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
10122                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10123                         return Some(expr3_0);
10124                     }
10125                 }
10126             }
10127             if let Some(pattern4_0) = C::is_gpr_type(ctx, pattern2_0) {
10128                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
10129                 if let &InstructionData::Load {
10130                     opcode: ref pattern6_0,
10131                     arg: pattern6_1,
10132                     flags: pattern6_2,
10133                     offset: pattern6_3,
10134                 } = &pattern5_0
10135                 {
10136                     if let &Opcode::Load = pattern6_0 {
10137                         // Rule at src/isa/x64/lower.isle line 2520.
10138                         let expr0_0 = C::ty_bits_u16(ctx, pattern3_0);
10139                         let expr1_0: u16 = 64;
10140                         let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
10141                         let expr3_0 =
10142                             constructor_to_amode(ctx, pattern6_2, pattern6_1, pattern6_3)?;
10143                         let expr4_0 = constructor_amode_to_gpr_mem(ctx, &expr3_0)?;
10144                         let expr5_0 = constructor_x64_movzx(ctx, &expr2_0, &expr4_0)?;
10145                         let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
10146                         return Some(expr6_0);
10147                     }
10148                 }
10149             }
10150         }
10151         if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) {
10152             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10153             match &pattern4_0 {
10154                 &InstructionData::UnaryImm {
10155                     opcode: ref pattern5_0,
10156                     imm: pattern5_1,
10157                 } => {
10158                     if let &Opcode::Iconst = pattern5_0 {
10159                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
10160                         // Rule at src/isa/x64/lower.isle line 10.
10161                         let expr0_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
10162                         let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
10163                         return Some(expr1_0);
10164                     }
10165                 }
10166                 &InstructionData::UnaryBool {
10167                     opcode: ref pattern5_0,
10168                     imm: pattern5_1,
10169                 } => {
10170                     if let &Opcode::Bconst = pattern5_0 {
10171                         if pattern5_1 == true {
10172                             // Rule at src/isa/x64/lower.isle line 28.
10173                             let expr0_0: u64 = 1;
10174                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
10175                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
10176                             return Some(expr2_0);
10177                         }
10178                         if pattern5_1 == false {
10179                             // Rule at src/isa/x64/lower.isle line 24.
10180                             let expr0_0: u64 = 0;
10181                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
10182                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
10183                             return Some(expr2_0);
10184                         }
10185                     }
10186                 }
10187                 &InstructionData::Binary {
10188                     opcode: ref pattern5_0,
10189                     args: ref pattern5_1,
10190                 } => {
10191                     match pattern5_0 {
10192                         &Opcode::Imin => {
10193                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10194                             // Rule at src/isa/x64/lower.isle line 1386.
10195                             let expr0_0 = CC::L;
10196                             let expr1_0 = constructor_cmp_and_choose(
10197                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
10198                             )?;
10199                             let expr2_0 = C::output(ctx, expr1_0);
10200                             return Some(expr2_0);
10201                         }
10202                         &Opcode::Umin => {
10203                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10204                             // Rule at src/isa/x64/lower.isle line 1380.
10205                             let expr0_0 = CC::B;
10206                             let expr1_0 = constructor_cmp_and_choose(
10207                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
10208                             )?;
10209                             let expr2_0 = C::output(ctx, expr1_0);
10210                             return Some(expr2_0);
10211                         }
10212                         &Opcode::Imax => {
10213                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10214                             // Rule at src/isa/x64/lower.isle line 1389.
10215                             let expr0_0 = CC::NL;
10216                             let expr1_0 = constructor_cmp_and_choose(
10217                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
10218                             )?;
10219                             let expr2_0 = C::output(ctx, expr1_0);
10220                             return Some(expr2_0);
10221                         }
10222                         &Opcode::Umax => {
10223                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10224                             // Rule at src/isa/x64/lower.isle line 1383.
10225                             let expr0_0 = CC::NB;
10226                             let expr1_0 = constructor_cmp_and_choose(
10227                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
10228                             )?;
10229                             let expr2_0 = C::output(ctx, expr1_0);
10230                             return Some(expr2_0);
10231                         }
10232                         &Opcode::Iadd => {
10233                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10234                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10235                                 // Rule at src/isa/x64/lower.isle line 74.
10236                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10237                                 let expr1_0 =
10238                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10239                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10240                                 return Some(expr2_0);
10241                             }
10242                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10243                                 // Rule at src/isa/x64/lower.isle line 86.
10244                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10245                                 let expr1_0 =
10246                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10247                                 let expr2_0 =
10248                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10249                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10250                                 return Some(expr3_0);
10251                             }
10252                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10253                                 // Rule at src/isa/x64/lower.isle line 70.
10254                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10255                                 let expr1_0 =
10256                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10257                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10258                                 return Some(expr2_0);
10259                             }
10260                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10261                                 // Rule at src/isa/x64/lower.isle line 80.
10262                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10263                                 let expr1_0 =
10264                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10265                                 let expr2_0 =
10266                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10267                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10268                                 return Some(expr3_0);
10269                             }
10270                             // Rule at src/isa/x64/lower.isle line 64.
10271                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10272                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10273                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10274                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10275                             return Some(expr3_0);
10276                         }
10277                         &Opcode::Isub => {
10278                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10279                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10280                                 // Rule at src/isa/x64/lower.isle line 228.
10281                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10282                                 let expr1_0 =
10283                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10284                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10285                                 return Some(expr2_0);
10286                             }
10287                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10288                                 // Rule at src/isa/x64/lower.isle line 233.
10289                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10290                                 let expr1_0 =
10291                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10292                                 let expr2_0 =
10293                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
10294                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10295                                 return Some(expr3_0);
10296                             }
10297                             // Rule at src/isa/x64/lower.isle line 223.
10298                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10299                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10300                             let expr2_0 = constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
10301                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10302                             return Some(expr3_0);
10303                         }
10304                         &Opcode::Imul => {
10305                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10306                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10307                                 // Rule at src/isa/x64/lower.isle line 925.
10308                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10309                                 let expr1_0 =
10310                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10311                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10312                                 return Some(expr2_0);
10313                             }
10314                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10315                                 // Rule at src/isa/x64/lower.isle line 937.
10316                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10317                                 let expr1_0 =
10318                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10319                                 let expr2_0 =
10320                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
10321                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10322                                 return Some(expr3_0);
10323                             }
10324                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10325                                 // Rule at src/isa/x64/lower.isle line 921.
10326                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10327                                 let expr1_0 =
10328                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10329                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10330                                 return Some(expr2_0);
10331                             }
10332                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10333                                 // Rule at src/isa/x64/lower.isle line 931.
10334                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10335                                 let expr1_0 =
10336                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10337                                 let expr2_0 =
10338                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
10339                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10340                                 return Some(expr3_0);
10341                             }
10342                             // Rule at src/isa/x64/lower.isle line 916.
10343                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10344                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10345                             let expr2_0 = constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
10346                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10347                             return Some(expr3_0);
10348                         }
10349                         &Opcode::IaddIfcout => {
10350                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10351                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10352                                 // Rule at src/isa/x64/lower.isle line 171.
10353                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10354                                 let expr1_0 =
10355                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10356                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
10357                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
10358                                 return Some(expr3_0);
10359                             }
10360                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10361                                 // Rule at src/isa/x64/lower.isle line 181.
10362                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10363                                 let expr1_0 =
10364                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10365                                 let expr2_0 =
10366                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10367                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
10368                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
10369                                 return Some(expr4_0);
10370                             }
10371                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10372                                 // Rule at src/isa/x64/lower.isle line 167.
10373                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10374                                 let expr1_0 =
10375                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10376                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
10377                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
10378                                 return Some(expr3_0);
10379                             }
10380                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10381                                 // Rule at src/isa/x64/lower.isle line 177.
10382                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10383                                 let expr1_0 =
10384                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10385                                 let expr2_0 =
10386                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10387                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
10388                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
10389                                 return Some(expr4_0);
10390                             }
10391                             // Rule at src/isa/x64/lower.isle line 161.
10392                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10393                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10394                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10395                             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
10396                             let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
10397                             return Some(expr4_0);
10398                         }
10399                         &Opcode::Band => {
10400                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10401                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10402                                 // Rule at src/isa/x64/lower.isle line 317.
10403                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10404                                 let expr1_0 =
10405                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10406                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10407                                 return Some(expr2_0);
10408                             }
10409                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10410                                 // Rule at src/isa/x64/lower.isle line 305.
10411                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10412                                 let expr1_0 =
10413                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10414                                 let expr2_0 =
10415                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
10416                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10417                                 return Some(expr3_0);
10418                             }
10419                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10420                                 // Rule at src/isa/x64/lower.isle line 313.
10421                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10422                                 let expr1_0 =
10423                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10424                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10425                                 return Some(expr2_0);
10426                             }
10427                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10428                                 // Rule at src/isa/x64/lower.isle line 300.
10429                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10430                                 let expr1_0 =
10431                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10432                                 let expr2_0 =
10433                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
10434                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10435                                 return Some(expr3_0);
10436                             }
10437                             // Rule at src/isa/x64/lower.isle line 295.
10438                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10439                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10440                             let expr2_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
10441                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10442                             return Some(expr3_0);
10443                         }
10444                         &Opcode::Bor => {
10445                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10446                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10447                                 // Rule at src/isa/x64/lower.isle line 381.
10448                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10449                                 let expr1_0 =
10450                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10451                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10452                                 return Some(expr2_0);
10453                             }
10454                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10455                                 // Rule at src/isa/x64/lower.isle line 370.
10456                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10457                                 let expr1_0 =
10458                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10459                                 let expr2_0 =
10460                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
10461                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10462                                 return Some(expr3_0);
10463                             }
10464                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10465                                 // Rule at src/isa/x64/lower.isle line 377.
10466                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10467                                 let expr1_0 =
10468                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10469                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10470                                 return Some(expr2_0);
10471                             }
10472                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10473                                 // Rule at src/isa/x64/lower.isle line 365.
10474                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10475                                 let expr1_0 =
10476                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10477                                 let expr2_0 =
10478                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
10479                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10480                                 return Some(expr3_0);
10481                             }
10482                             // Rule at src/isa/x64/lower.isle line 360.
10483                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10484                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10485                             let expr2_0 = constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
10486                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10487                             return Some(expr3_0);
10488                         }
10489                         &Opcode::Bxor => {
10490                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10491                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10492                                 // Rule at src/isa/x64/lower.isle line 447.
10493                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10494                                 let expr1_0 =
10495                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10496                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10497                                 return Some(expr2_0);
10498                             }
10499                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10500                                 // Rule at src/isa/x64/lower.isle line 436.
10501                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10502                                 let expr1_0 =
10503                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10504                                 let expr2_0 =
10505                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
10506                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10507                                 return Some(expr3_0);
10508                             }
10509                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10510                                 // Rule at src/isa/x64/lower.isle line 443.
10511                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10512                                 let expr1_0 =
10513                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10514                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10515                                 return Some(expr2_0);
10516                             }
10517                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10518                                 // Rule at src/isa/x64/lower.isle line 431.
10519                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10520                                 let expr1_0 =
10521                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10522                                 let expr2_0 =
10523                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
10524                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10525                                 return Some(expr3_0);
10526                             }
10527                             // Rule at src/isa/x64/lower.isle line 426.
10528                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10529                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10530                             let expr2_0 = constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
10531                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10532                             return Some(expr3_0);
10533                         }
10534                         &Opcode::Ishl => {
10535                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10536                             // Rule at src/isa/x64/lower.isle line 483.
10537                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10538                             let expr1_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
10539                             let expr2_0 = constructor_x64_shl(ctx, pattern3_0, expr0_0, &expr1_0)?;
10540                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10541                             return Some(expr3_0);
10542                         }
10543                         &Opcode::Ushr => {
10544                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10545                             // Rule at src/isa/x64/lower.isle line 589.
10546                             let expr0_0 = ExtendKind::Zero;
10547                             let expr1_0 =
10548                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
10549                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
10550                             let expr3_0 = constructor_x64_shr(ctx, pattern3_0, expr1_0, &expr2_0)?;
10551                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10552                             return Some(expr4_0);
10553                         }
10554                         &Opcode::Sshr => {
10555                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10556                             // Rule at src/isa/x64/lower.isle line 691.
10557                             let expr0_0 = ExtendKind::Sign;
10558                             let expr1_0 =
10559                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
10560                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
10561                             let expr3_0 = constructor_x64_sar(ctx, pattern3_0, expr1_0, &expr2_0)?;
10562                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10563                             return Some(expr4_0);
10564                         }
10565                         _ => {}
10566                     }
10567                 }
10568                 &InstructionData::Unary {
10569                     opcode: ref pattern5_0,
10570                     arg: pattern5_1,
10571                 } => {
10572                     match pattern5_0 {
10573                         &Opcode::Ineg => {
10574                             // Rule at src/isa/x64/lower.isle line 884.
10575                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10576                             let expr1_0 = constructor_x64_neg(ctx, pattern3_0, expr0_0)?;
10577                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10578                             return Some(expr2_0);
10579                         }
10580                         &Opcode::Bnot => {
10581                             // Rule at src/isa/x64/lower.isle line 1253.
10582                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10583                             let expr1_0 = constructor_x64_not(ctx, pattern3_0, expr0_0)?;
10584                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10585                             return Some(expr2_0);
10586                         }
10587                         &Opcode::Breduce => {
10588                             // Rule at src/isa/x64/lower.isle line 2235.
10589                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
10590                             let expr1_0: usize = 0;
10591                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
10592                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10593                             return Some(expr3_0);
10594                         }
10595                         &Opcode::Bint => {
10596                             // Rule at src/isa/x64/lower.isle line 2243.
10597                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10598                             let expr1_0: u32 = 1;
10599                             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
10600                             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
10601                             let expr4_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr3_0)?;
10602                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
10603                             return Some(expr5_0);
10604                         }
10605                         &Opcode::Ireduce => {
10606                             // Rule at src/isa/x64/lower.isle line 2227.
10607                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
10608                             let expr1_0: usize = 0;
10609                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
10610                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10611                             return Some(expr3_0);
10612                         }
10613                         _ => {}
10614                     }
10615                 }
10616                 &InstructionData::BinaryImm64 {
10617                     opcode: ref pattern5_0,
10618                     arg: pattern5_1,
10619                     imm: pattern5_2,
10620                 } => {
10621                     if let &Opcode::IaddImm = pattern5_0 {
10622                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
10623                         // Rule at src/isa/x64/lower.isle line 196.
10624                         let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10625                         let expr1_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
10626                         let expr2_0 = constructor_reg_to_gpr_mem_imm(ctx, expr1_0)?;
10627                         let expr3_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr2_0)?;
10628                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10629                         return Some(expr4_0);
10630                     }
10631                 }
10632                 _ => {}
10633             }
10634         }
10635         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
10636             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10637             match &pattern4_0 {
10638                 &InstructionData::Binary {
10639                     opcode: ref pattern5_0,
10640                     args: ref pattern5_1,
10641                 } => {
10642                     match pattern5_0 {
10643                         &Opcode::Rotl => {
10644                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10645                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
10646                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
10647                                 if let &InstructionData::UnaryImm {
10648                                     opcode: ref pattern10_0,
10649                                     imm: pattern10_1,
10650                                 } = &pattern9_0
10651                                 {
10652                                     if let &Opcode::Iconst = pattern10_0 {
10653                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
10654                                         // Rule at src/isa/x64/lower.isle line 823.
10655                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10656                                         let expr1_0 = C::const_to_type_masked_imm8(
10657                                             ctx,
10658                                             pattern12_0,
10659                                             pattern3_0,
10660                                         );
10661                                         let expr2_0 = constructor_x64_rotl(
10662                                             ctx, pattern3_0, expr0_0, &expr1_0,
10663                                         )?;
10664                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10665                                         return Some(expr3_0);
10666                                     }
10667                                 }
10668                             }
10669                             // Rule at src/isa/x64/lower.isle line 817.
10670                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
10671                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10672                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
10673                             let expr3_0 = constructor_x64_rotl(ctx, pattern3_0, expr1_0, &expr2_0)?;
10674                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10675                             return Some(expr4_0);
10676                         }
10677                         &Opcode::Rotr => {
10678                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10679                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
10680                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
10681                                 if let &InstructionData::UnaryImm {
10682                                     opcode: ref pattern10_0,
10683                                     imm: pattern10_1,
10684                                 } = &pattern9_0
10685                                 {
10686                                     if let &Opcode::Iconst = pattern10_0 {
10687                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
10688                                         // Rule at src/isa/x64/lower.isle line 863.
10689                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10690                                         let expr1_0 = C::const_to_type_masked_imm8(
10691                                             ctx,
10692                                             pattern12_0,
10693                                             pattern3_0,
10694                                         );
10695                                         let expr2_0 = constructor_x64_rotr(
10696                                             ctx, pattern3_0, expr0_0, &expr1_0,
10697                                         )?;
10698                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10699                                         return Some(expr3_0);
10700                                     }
10701                                 }
10702                             }
10703                             // Rule at src/isa/x64/lower.isle line 857.
10704                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
10705                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10706                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
10707                             let expr3_0 = constructor_x64_rotr(ctx, pattern3_0, expr1_0, &expr2_0)?;
10708                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10709                             return Some(expr4_0);
10710                         }
10711                         _ => {}
10712                     }
10713                 }
10714                 &InstructionData::Unary {
10715                     opcode: ref pattern5_0,
10716                     arg: pattern5_1,
10717                 } => {
10718                     match pattern5_0 {
10719                         &Opcode::Clz => {
10720                             // Rule at src/isa/x64/lower.isle line 1791.
10721                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10722                             let expr1_0 = constructor_do_clz(ctx, pattern3_0, pattern3_0, expr0_0)?;
10723                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10724                             return Some(expr2_0);
10725                         }
10726                         &Opcode::Ctz => {
10727                             // Rule at src/isa/x64/lower.isle line 1833.
10728                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10729                             let expr1_0 = constructor_do_ctz(ctx, pattern3_0, pattern3_0, expr0_0)?;
10730                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10731                             return Some(expr2_0);
10732                         }
10733                         &Opcode::Popcnt => {
10734                             // Rule at src/isa/x64/lower.isle line 1885.
10735                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10736                             let expr1_0 = constructor_do_popcnt(ctx, pattern3_0, expr0_0)?;
10737                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10738                             return Some(expr2_0);
10739                         }
10740                         _ => {}
10741                     }
10742                 }
10743                 _ => {}
10744             }
10745         }
10746         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
10747             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10748             match &pattern4_0 {
10749                 &InstructionData::Binary {
10750                     opcode: ref pattern5_0,
10751                     args: ref pattern5_1,
10752                 } => {
10753                     match pattern5_0 {
10754                         &Opcode::Rotl => {
10755                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10756                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
10757                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
10758                                 if let &InstructionData::UnaryImm {
10759                                     opcode: ref pattern10_0,
10760                                     imm: pattern10_1,
10761                                 } = &pattern9_0
10762                                 {
10763                                     if let &Opcode::Iconst = pattern10_0 {
10764                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
10765                                         // Rule at src/isa/x64/lower.isle line 809.
10766                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10767                                         let expr1_0 = C::const_to_type_masked_imm8(
10768                                             ctx,
10769                                             pattern12_0,
10770                                             pattern3_0,
10771                                         );
10772                                         let expr2_0 = constructor_x64_rotl(
10773                                             ctx, pattern3_0, expr0_0, &expr1_0,
10774                                         )?;
10775                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10776                                         return Some(expr3_0);
10777                                     }
10778                                 }
10779                             }
10780                             // Rule at src/isa/x64/lower.isle line 805.
10781                             let expr0_0: Type = I32;
10782                             let expr1_0 = ExtendKind::Zero;
10783                             let expr2_0 =
10784                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
10785                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10786                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
10787                             let expr5_0 = constructor_x64_rotl(ctx, pattern3_0, expr3_0, &expr4_0)?;
10788                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
10789                             return Some(expr6_0);
10790                         }
10791                         &Opcode::Rotr => {
10792                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10793                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
10794                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
10795                                 if let &InstructionData::UnaryImm {
10796                                     opcode: ref pattern10_0,
10797                                     imm: pattern10_1,
10798                                 } = &pattern9_0
10799                                 {
10800                                     if let &Opcode::Iconst = pattern10_0 {
10801                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
10802                                         // Rule at src/isa/x64/lower.isle line 849.
10803                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10804                                         let expr1_0 = C::const_to_type_masked_imm8(
10805                                             ctx,
10806                                             pattern12_0,
10807                                             pattern3_0,
10808                                         );
10809                                         let expr2_0 = constructor_x64_rotr(
10810                                             ctx, pattern3_0, expr0_0, &expr1_0,
10811                                         )?;
10812                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10813                                         return Some(expr3_0);
10814                                     }
10815                                 }
10816                             }
10817                             // Rule at src/isa/x64/lower.isle line 845.
10818                             let expr0_0: Type = I32;
10819                             let expr1_0 = ExtendKind::Zero;
10820                             let expr2_0 =
10821                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
10822                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10823                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
10824                             let expr5_0 = constructor_x64_rotr(ctx, pattern3_0, expr3_0, &expr4_0)?;
10825                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
10826                             return Some(expr6_0);
10827                         }
10828                         _ => {}
10829                     }
10830                 }
10831                 &InstructionData::Unary {
10832                     opcode: ref pattern5_0,
10833                     arg: pattern5_1,
10834                 } => {
10835                     match pattern5_0 {
10836                         &Opcode::Clz => {
10837                             // Rule at src/isa/x64/lower.isle line 1796.
10838                             let expr0_0: Type = I32;
10839                             let expr1_0: Type = I32;
10840                             let expr2_0 = ExtendKind::Zero;
10841                             let expr3_0 =
10842                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
10843                             let expr4_0 = constructor_do_clz(ctx, expr0_0, pattern3_0, expr3_0)?;
10844                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
10845                             return Some(expr5_0);
10846                         }
10847                         &Opcode::Ctz => {
10848                             // Rule at src/isa/x64/lower.isle line 1838.
10849                             let expr0_0: Type = I32;
10850                             let expr1_0: Type = I32;
10851                             let expr2_0 = ExtendKind::Zero;
10852                             let expr3_0 =
10853                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
10854                             let expr4_0 = constructor_do_ctz(ctx, expr0_0, pattern3_0, expr3_0)?;
10855                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
10856                             return Some(expr5_0);
10857                         }
10858                         &Opcode::Popcnt => {
10859                             // Rule at src/isa/x64/lower.isle line 1890.
10860                             let expr0_0: Type = I32;
10861                             let expr1_0: Type = I32;
10862                             let expr2_0 = ExtendKind::Zero;
10863                             let expr3_0 =
10864                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
10865                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
10866                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
10867                             return Some(expr5_0);
10868                         }
10869                         _ => {}
10870                     }
10871                 }
10872                 _ => {}
10873             }
10874         }
10875         if let Some(pattern3_0) = C::ty_int_bool_ref_64(ctx, pattern2_0) {
10876             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10877             if let &InstructionData::Load {
10878                 opcode: ref pattern5_0,
10879                 arg: pattern5_1,
10880                 flags: pattern5_2,
10881                 offset: pattern5_3,
10882             } = &pattern4_0
10883             {
10884                 if let &Opcode::Load = pattern5_0 {
10885                     // Rule at src/isa/x64/lower.isle line 2524.
10886                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10887                     let expr1_0 = constructor_x64_mov(ctx, &expr0_0)?;
10888                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
10889                     return Some(expr2_0);
10890                 }
10891             }
10892         }
10893         if let Some(pattern3_0) = C::ty_int_bool_128(ctx, pattern2_0) {
10894             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10895             if let &InstructionData::Load {
10896                 opcode: ref pattern5_0,
10897                 arg: pattern5_1,
10898                 flags: pattern5_2,
10899                 offset: pattern5_3,
10900             } = &pattern4_0
10901             {
10902                 if let &Opcode::Load = pattern5_0 {
10903                     // Rule at src/isa/x64/lower.isle line 2558.
10904                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10905                     let expr1_0: u32 = 8;
10906                     let expr2_0 = C::amode_offset(ctx, &expr0_0, expr1_0);
10907                     let expr3_0 = constructor_x64_mov(ctx, &expr0_0)?;
10908                     let expr4_0 = constructor_x64_mov(ctx, &expr2_0)?;
10909                     let expr5_0 = C::value_regs(ctx, expr3_0, expr4_0);
10910                     let expr6_0 = C::output(ctx, expr5_0);
10911                     return Some(expr6_0);
10912                 }
10913             }
10914         }
10915         if let Some(pattern3_0) = C::ty_vec128(ctx, pattern2_0) {
10916             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10917             if let &InstructionData::Load {
10918                 opcode: ref pattern5_0,
10919                 arg: pattern5_1,
10920                 flags: pattern5_2,
10921                 offset: pattern5_3,
10922             } = &pattern4_0
10923             {
10924                 if let &Opcode::Load = pattern5_0 {
10925                     // Rule at src/isa/x64/lower.isle line 2554.
10926                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10927                     let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
10928                     let expr2_0 = constructor_x64_movdqu(ctx, &expr1_0)?;
10929                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10930                     return Some(expr3_0);
10931                 }
10932             }
10933         }
10934         if let Some(pattern3_0) = C::is_gpr_type(ctx, pattern2_0) {
10935             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10936             if let &InstructionData::Load {
10937                 opcode: ref pattern5_0,
10938                 arg: pattern5_1,
10939                 flags: pattern5_2,
10940                 offset: pattern5_3,
10941             } = &pattern4_0
10942             {
10943                 match pattern5_0 {
10944                     &Opcode::Uload8 => {
10945                         // Rule at src/isa/x64/lower.isle line 2529.
10946                         let expr0_0 = ExtMode::BQ;
10947                         let expr1_0 =
10948                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10949                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10950                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10951                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10952                         return Some(expr4_0);
10953                     }
10954                     &Opcode::Sload8 => {
10955                         // Rule at src/isa/x64/lower.isle line 2531.
10956                         let expr0_0 = ExtMode::BQ;
10957                         let expr1_0 =
10958                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10959                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10960                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10961                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10962                         return Some(expr4_0);
10963                     }
10964                     &Opcode::Uload16 => {
10965                         // Rule at src/isa/x64/lower.isle line 2533.
10966                         let expr0_0 = ExtMode::WQ;
10967                         let expr1_0 =
10968                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10969                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10970                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10971                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10972                         return Some(expr4_0);
10973                     }
10974                     &Opcode::Sload16 => {
10975                         // Rule at src/isa/x64/lower.isle line 2535.
10976                         let expr0_0 = ExtMode::WQ;
10977                         let expr1_0 =
10978                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10979                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10980                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10981                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10982                         return Some(expr4_0);
10983                     }
10984                     &Opcode::Uload32 => {
10985                         // Rule at src/isa/x64/lower.isle line 2537.
10986                         let expr0_0 = ExtMode::LQ;
10987                         let expr1_0 =
10988                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10989                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10990                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10991                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10992                         return Some(expr4_0);
10993                     }
10994                     &Opcode::Sload32 => {
10995                         // Rule at src/isa/x64/lower.isle line 2539.
10996                         let expr0_0 = ExtMode::LQ;
10997                         let expr1_0 =
10998                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10999                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
11000                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
11001                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
11002                         return Some(expr4_0);
11003                     }
11004                     _ => {}
11005                 }
11006             }
11007         }
11008     }
11009     return None;
11010 }
11011 
11012 // Generated as internal constructor for term output_ifcout.
11013 pub fn constructor_output_ifcout<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
11014     let pattern0_0 = arg0;
11015     // Rule at src/isa/x64/lower.isle line 157.
11016     let expr0_0 = C::value_reg(ctx, pattern0_0);
11017     let expr1_0 = C::value_regs_invalid(ctx);
11018     let expr2_0 = C::output_pair(ctx, expr0_0, expr1_0);
11019     return Some(expr2_0);
11020 }
11021 
11022 // Generated as internal constructor for term sse_and.
11023 pub fn constructor_sse_and<C: Context>(
11024     ctx: &mut C,
11025     arg0: Type,
11026     arg1: Xmm,
11027     arg2: &XmmMem,
11028 ) -> Option<Xmm> {
11029     let pattern0_0 = arg0;
11030     if pattern0_0 == F32X4 {
11031         let pattern2_0 = arg1;
11032         let pattern3_0 = arg2;
11033         // Rule at src/isa/x64/lower.isle line 324.
11034         let expr0_0 = constructor_x64_andps(ctx, pattern2_0, pattern3_0)?;
11035         return Some(expr0_0);
11036     }
11037     if pattern0_0 == F64X2 {
11038         let pattern2_0 = arg1;
11039         let pattern3_0 = arg2;
11040         // Rule at src/isa/x64/lower.isle line 325.
11041         let expr0_0 = constructor_x64_andpd(ctx, pattern2_0, pattern3_0)?;
11042         return Some(expr0_0);
11043     }
11044     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
11045         let pattern2_0 = arg1;
11046         let pattern3_0 = arg2;
11047         // Rule at src/isa/x64/lower.isle line 326.
11048         let expr0_0 = constructor_x64_pand(ctx, pattern2_0, pattern3_0)?;
11049         return Some(expr0_0);
11050     }
11051     return None;
11052 }
11053 
11054 // Generated as internal constructor for term sse_or.
11055 pub fn constructor_sse_or<C: Context>(
11056     ctx: &mut C,
11057     arg0: Type,
11058     arg1: Xmm,
11059     arg2: &XmmMem,
11060 ) -> Option<Xmm> {
11061     let pattern0_0 = arg0;
11062     if pattern0_0 == F32X4 {
11063         let pattern2_0 = arg1;
11064         let pattern3_0 = arg2;
11065         // Rule at src/isa/x64/lower.isle line 388.
11066         let expr0_0 = constructor_x64_orps(ctx, pattern2_0, pattern3_0)?;
11067         return Some(expr0_0);
11068     }
11069     if pattern0_0 == F64X2 {
11070         let pattern2_0 = arg1;
11071         let pattern3_0 = arg2;
11072         // Rule at src/isa/x64/lower.isle line 389.
11073         let expr0_0 = constructor_x64_orpd(ctx, pattern2_0, pattern3_0)?;
11074         return Some(expr0_0);
11075     }
11076     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
11077         let pattern2_0 = arg1;
11078         let pattern3_0 = arg2;
11079         // Rule at src/isa/x64/lower.isle line 390.
11080         let expr0_0 = constructor_x64_por(ctx, pattern2_0, pattern3_0)?;
11081         return Some(expr0_0);
11082     }
11083     return None;
11084 }
11085 
11086 // Generated as internal constructor for term or_i128.
11087 pub fn constructor_or_i128<C: Context>(
11088     ctx: &mut C,
11089     arg0: ValueRegs,
11090     arg1: ValueRegs,
11091 ) -> Option<ValueRegs> {
11092     let pattern0_0 = arg0;
11093     let pattern1_0 = arg1;
11094     // Rule at src/isa/x64/lower.isle line 399.
11095     let expr0_0: usize = 0;
11096     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
11097     let expr2_0: usize = 1;
11098     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
11099     let expr4_0: usize = 0;
11100     let expr5_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr4_0)?;
11101     let expr6_0: usize = 1;
11102     let expr7_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr6_0)?;
11103     let expr8_0: Type = I64;
11104     let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11105     let expr10_0 = constructor_x64_or(ctx, expr8_0, expr1_0, &expr9_0)?;
11106     let expr11_0: Type = I64;
11107     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
11108     let expr13_0 = constructor_x64_or(ctx, expr11_0, expr3_0, &expr12_0)?;
11109     let expr14_0 = constructor_value_gprs(ctx, expr10_0, expr13_0)?;
11110     return Some(expr14_0);
11111 }
11112 
11113 // Generated as internal constructor for term shl_i128.
11114 pub fn constructor_shl_i128<C: Context>(
11115     ctx: &mut C,
11116     arg0: ValueRegs,
11117     arg1: Gpr,
11118 ) -> Option<ValueRegs> {
11119     let pattern0_0 = arg0;
11120     let pattern1_0 = arg1;
11121     // Rule at src/isa/x64/lower.isle line 489.
11122     let expr0_0: usize = 0;
11123     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
11124     let expr2_0: usize = 1;
11125     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
11126     let expr4_0: Type = I64;
11127     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11128     let expr6_0 = constructor_x64_shl(ctx, expr4_0, expr1_0, &expr5_0)?;
11129     let expr7_0: Type = I64;
11130     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11131     let expr9_0 = constructor_x64_shl(ctx, expr7_0, expr3_0, &expr8_0)?;
11132     let expr10_0: Type = I64;
11133     let expr11_0: Type = I64;
11134     let expr12_0: Type = I64;
11135     let expr13_0: u64 = 64;
11136     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
11137     let expr15_0 = C::gpr_new(ctx, expr14_0);
11138     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
11139     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
11140     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
11141     let expr19_0 = constructor_x64_shr(ctx, expr10_0, expr1_0, &expr18_0)?;
11142     let expr20_0: Type = I64;
11143     let expr21_0: u64 = 0;
11144     let expr22_0 = constructor_imm(ctx, expr20_0, expr21_0)?;
11145     let expr23_0 = C::gpr_new(ctx, expr22_0);
11146     let expr24_0 = OperandSize::Size64;
11147     let expr25_0: u32 = 127;
11148     let expr26_0 = RegMemImm::Imm { simm32: expr25_0 };
11149     let expr27_0 = C::gpr_mem_imm_new(ctx, &expr26_0);
11150     let expr28_0 = constructor_x64_test(ctx, &expr24_0, &expr27_0, pattern1_0)?;
11151     let expr29_0: Type = I64;
11152     let expr30_0 = CC::Z;
11153     let expr31_0 = C::gpr_to_gpr_mem(ctx, expr23_0);
11154     let expr32_0 = constructor_cmove(ctx, expr29_0, &expr30_0, &expr31_0, expr19_0)?;
11155     let expr33_0 = constructor_with_flags_reg(ctx, &expr28_0, &expr32_0)?;
11156     let expr34_0 = C::gpr_new(ctx, expr33_0);
11157     let expr35_0: Type = I64;
11158     let expr36_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
11159     let expr37_0 = constructor_x64_or(ctx, expr35_0, expr34_0, &expr36_0)?;
11160     let expr38_0 = OperandSize::Size64;
11161     let expr39_0: u32 = 64;
11162     let expr40_0 = RegMemImm::Imm { simm32: expr39_0 };
11163     let expr41_0 = C::gpr_mem_imm_new(ctx, &expr40_0);
11164     let expr42_0 = constructor_x64_test(ctx, &expr38_0, &expr41_0, pattern1_0)?;
11165     let expr43_0: Type = I64;
11166     let expr44_0 = CC::Z;
11167     let expr45_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
11168     let expr46_0 = constructor_cmove(ctx, expr43_0, &expr44_0, &expr45_0, expr23_0)?;
11169     let expr47_0: Type = I64;
11170     let expr48_0 = CC::Z;
11171     let expr49_0 = C::gpr_to_gpr_mem(ctx, expr37_0);
11172     let expr50_0 = constructor_cmove(ctx, expr47_0, &expr48_0, &expr49_0, expr6_0)?;
11173     let expr51_0 = constructor_consumes_flags_concat(ctx, &expr46_0, &expr50_0)?;
11174     let expr52_0 = constructor_with_flags(ctx, &expr42_0, &expr51_0)?;
11175     return Some(expr52_0);
11176 }
11177 
11178 // Generated as internal constructor for term ishl_i8x16_mask.
11179 pub fn constructor_ishl_i8x16_mask<C: Context>(
11180     ctx: &mut C,
11181     arg0: &RegMemImm,
11182 ) -> Option<SyntheticAmode> {
11183     let pattern0_0 = arg0;
11184     match pattern0_0 {
11185         &RegMemImm::Imm { simm32: pattern1_0 } => {
11186             // Rule at src/isa/x64/lower.isle line 552.
11187             let expr0_0 = C::ishl_i8x16_mask_for_const(ctx, pattern1_0);
11188             return Some(expr0_0);
11189         }
11190         &RegMemImm::Reg { reg: pattern1_0 } => {
11191             // Rule at src/isa/x64/lower.isle line 561.
11192             let expr0_0 = C::ishl_i8x16_mask_table(ctx);
11193             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
11194             let expr2_0: Type = I64;
11195             let expr3_0 = C::gpr_new(ctx, pattern1_0);
11196             let expr4_0: u8 = 4;
11197             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
11198             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
11199             let expr7_0: u32 = 0;
11200             let expr8_0: u8 = 0;
11201             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
11202             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
11203             return Some(expr10_0);
11204         }
11205         &RegMemImm::Mem {
11206             addr: ref pattern1_0,
11207         } => {
11208             // Rule at src/isa/x64/lower.isle line 571.
11209             let expr0_0: Type = I64;
11210             let expr1_0 = ExtKind::None;
11211             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
11212             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
11213             let expr4_0 = constructor_ishl_i8x16_mask(ctx, &expr3_0)?;
11214             return Some(expr4_0);
11215         }
11216         _ => {}
11217     }
11218     return None;
11219 }
11220 
11221 // Generated as internal constructor for term shr_i128.
11222 pub fn constructor_shr_i128<C: Context>(
11223     ctx: &mut C,
11224     arg0: ValueRegs,
11225     arg1: Gpr,
11226 ) -> Option<ValueRegs> {
11227     let pattern0_0 = arg0;
11228     let pattern1_0 = arg1;
11229     // Rule at src/isa/x64/lower.isle line 596.
11230     let expr0_0: usize = 0;
11231     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
11232     let expr2_0: usize = 1;
11233     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
11234     let expr4_0: Type = I64;
11235     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11236     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
11237     let expr7_0: Type = I64;
11238     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11239     let expr9_0 = constructor_x64_shr(ctx, expr7_0, expr3_0, &expr8_0)?;
11240     let expr10_0: Type = I64;
11241     let expr11_0: Type = I64;
11242     let expr12_0: Type = I64;
11243     let expr13_0: u64 = 64;
11244     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
11245     let expr15_0 = C::gpr_new(ctx, expr14_0);
11246     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
11247     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
11248     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
11249     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
11250     let expr20_0 = OperandSize::Size64;
11251     let expr21_0: u32 = 127;
11252     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
11253     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
11254     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
11255     let expr25_0: Type = I64;
11256     let expr26_0 = CC::Z;
11257     let expr27_0: Type = I64;
11258     let expr28_0: u64 = 0;
11259     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
11260     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
11261     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
11262     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
11263     let expr33_0 = C::gpr_new(ctx, expr32_0);
11264     let expr34_0: Type = I64;
11265     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr6_0);
11266     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr33_0, &expr35_0)?;
11267     let expr37_0 = OperandSize::Size64;
11268     let expr38_0: u32 = 64;
11269     let expr39_0 = RegMemImm::Imm { simm32: expr38_0 };
11270     let expr40_0 = C::gpr_mem_imm_new(ctx, &expr39_0);
11271     let expr41_0 = constructor_x64_test(ctx, &expr37_0, &expr40_0, pattern1_0)?;
11272     let expr42_0: Type = I64;
11273     let expr43_0 = CC::Z;
11274     let expr44_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
11275     let expr45_0 = constructor_cmove(ctx, expr42_0, &expr43_0, &expr44_0, expr9_0)?;
11276     let expr46_0: Type = I64;
11277     let expr47_0 = CC::Z;
11278     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
11279     let expr49_0: Type = I64;
11280     let expr50_0: u64 = 0;
11281     let expr51_0 = constructor_imm(ctx, expr49_0, expr50_0)?;
11282     let expr52_0 = C::gpr_new(ctx, expr51_0);
11283     let expr53_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr52_0)?;
11284     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr45_0, &expr53_0)?;
11285     let expr55_0 = constructor_with_flags(ctx, &expr41_0, &expr54_0)?;
11286     return Some(expr55_0);
11287 }
11288 
11289 // Generated as internal constructor for term ushr_i8x16_mask.
11290 pub fn constructor_ushr_i8x16_mask<C: Context>(
11291     ctx: &mut C,
11292     arg0: &RegMemImm,
11293 ) -> Option<SyntheticAmode> {
11294     let pattern0_0 = arg0;
11295     match pattern0_0 {
11296         &RegMemImm::Imm { simm32: pattern1_0 } => {
11297             // Rule at src/isa/x64/lower.isle line 653.
11298             let expr0_0 = C::ushr_i8x16_mask_for_const(ctx, pattern1_0);
11299             return Some(expr0_0);
11300         }
11301         &RegMemImm::Reg { reg: pattern1_0 } => {
11302             // Rule at src/isa/x64/lower.isle line 662.
11303             let expr0_0 = C::ushr_i8x16_mask_table(ctx);
11304             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
11305             let expr2_0: Type = I64;
11306             let expr3_0 = C::gpr_new(ctx, pattern1_0);
11307             let expr4_0: u8 = 4;
11308             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
11309             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
11310             let expr7_0: u32 = 0;
11311             let expr8_0: u8 = 0;
11312             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
11313             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
11314             return Some(expr10_0);
11315         }
11316         &RegMemImm::Mem {
11317             addr: ref pattern1_0,
11318         } => {
11319             // Rule at src/isa/x64/lower.isle line 673.
11320             let expr0_0: Type = I64;
11321             let expr1_0 = ExtKind::None;
11322             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
11323             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
11324             let expr4_0 = constructor_ushr_i8x16_mask(ctx, &expr3_0)?;
11325             return Some(expr4_0);
11326         }
11327         _ => {}
11328     }
11329     return None;
11330 }
11331 
11332 // Generated as internal constructor for term sar_i128.
11333 pub fn constructor_sar_i128<C: Context>(
11334     ctx: &mut C,
11335     arg0: ValueRegs,
11336     arg1: Gpr,
11337 ) -> Option<ValueRegs> {
11338     let pattern0_0 = arg0;
11339     let pattern1_0 = arg1;
11340     // Rule at src/isa/x64/lower.isle line 698.
11341     let expr0_0: usize = 0;
11342     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
11343     let expr2_0: usize = 1;
11344     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
11345     let expr4_0: Type = I64;
11346     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11347     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
11348     let expr7_0: Type = I64;
11349     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11350     let expr9_0 = constructor_x64_sar(ctx, expr7_0, expr3_0, &expr8_0)?;
11351     let expr10_0: Type = I64;
11352     let expr11_0: Type = I64;
11353     let expr12_0: Type = I64;
11354     let expr13_0: u64 = 64;
11355     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
11356     let expr15_0 = C::gpr_new(ctx, expr14_0);
11357     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
11358     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
11359     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
11360     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
11361     let expr20_0 = OperandSize::Size64;
11362     let expr21_0: u32 = 127;
11363     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
11364     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
11365     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
11366     let expr25_0: Type = I64;
11367     let expr26_0 = CC::Z;
11368     let expr27_0: Type = I64;
11369     let expr28_0: u64 = 0;
11370     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
11371     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
11372     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
11373     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
11374     let expr33_0 = C::gpr_new(ctx, expr32_0);
11375     let expr34_0: Type = I64;
11376     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
11377     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr6_0, &expr35_0)?;
11378     let expr37_0: Type = I64;
11379     let expr38_0: u8 = 63;
11380     let expr39_0 = C::imm8_to_imm8_gpr(ctx, expr38_0);
11381     let expr40_0 = constructor_x64_sar(ctx, expr37_0, expr3_0, &expr39_0)?;
11382     let expr41_0 = OperandSize::Size64;
11383     let expr42_0: u32 = 64;
11384     let expr43_0 = RegMemImm::Imm { simm32: expr42_0 };
11385     let expr44_0 = C::gpr_mem_imm_new(ctx, &expr43_0);
11386     let expr45_0 = constructor_x64_test(ctx, &expr41_0, &expr44_0, pattern1_0)?;
11387     let expr46_0: Type = I64;
11388     let expr47_0 = CC::Z;
11389     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
11390     let expr49_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr9_0)?;
11391     let expr50_0: Type = I64;
11392     let expr51_0 = CC::Z;
11393     let expr52_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
11394     let expr53_0 = constructor_cmove(ctx, expr50_0, &expr51_0, &expr52_0, expr40_0)?;
11395     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr49_0, &expr53_0)?;
11396     let expr55_0 = constructor_with_flags(ctx, &expr45_0, &expr54_0)?;
11397     return Some(expr55_0);
11398 }
11399 
11400 // Generated as internal constructor for term sshr_i8x16_bigger_shift.
11401 pub fn constructor_sshr_i8x16_bigger_shift<C: Context>(
11402     ctx: &mut C,
11403     arg0: Type,
11404     arg1: &RegMemImm,
11405 ) -> Option<XmmMemImm> {
11406     let pattern0_0 = arg0;
11407     let pattern1_0 = arg1;
11408     match pattern1_0 {
11409         &RegMemImm::Imm { simm32: pattern2_0 } => {
11410             // Rule at src/isa/x64/lower.isle line 762.
11411             let expr0_0: u32 = 8;
11412             let expr1_0 = C::u32_add(ctx, pattern2_0, expr0_0);
11413             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
11414             let expr3_0 = C::xmm_mem_imm_new(ctx, &expr2_0);
11415             return Some(expr3_0);
11416         }
11417         &RegMemImm::Reg { reg: pattern2_0 } => {
11418             // Rule at src/isa/x64/lower.isle line 764.
11419             let expr0_0 = C::gpr_new(ctx, pattern2_0);
11420             let expr1_0: u32 = 8;
11421             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
11422             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
11423             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr0_0, &expr3_0)?;
11424             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
11425             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
11426             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
11427             return Some(expr7_0);
11428         }
11429         &RegMemImm::Mem {
11430             addr: ref pattern2_0,
11431         } => {
11432             // Rule at src/isa/x64/lower.isle line 768.
11433             let expr0_0: u64 = 8;
11434             let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
11435             let expr2_0 = C::gpr_new(ctx, expr1_0);
11436             let expr3_0 = C::gpr_mem_imm_new(ctx, pattern1_0);
11437             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr2_0, &expr3_0)?;
11438             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
11439             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
11440             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
11441             return Some(expr7_0);
11442         }
11443         _ => {}
11444     }
11445     return None;
11446 }
11447 
11448 // Generated as internal constructor for term sse_and_not.
11449 pub fn constructor_sse_and_not<C: Context>(
11450     ctx: &mut C,
11451     arg0: Type,
11452     arg1: Xmm,
11453     arg2: &XmmMem,
11454 ) -> Option<Xmm> {
11455     let pattern0_0 = arg0;
11456     if pattern0_0 == F32X4 {
11457         let pattern2_0 = arg1;
11458         let pattern3_0 = arg2;
11459         // Rule at src/isa/x64/lower.isle line 1194.
11460         let expr0_0 = constructor_x64_andnps(ctx, pattern2_0, pattern3_0)?;
11461         return Some(expr0_0);
11462     }
11463     if pattern0_0 == F64X2 {
11464         let pattern2_0 = arg1;
11465         let pattern3_0 = arg2;
11466         // Rule at src/isa/x64/lower.isle line 1195.
11467         let expr0_0 = constructor_x64_andnpd(ctx, pattern2_0, pattern3_0)?;
11468         return Some(expr0_0);
11469     }
11470     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
11471         let pattern2_0 = arg1;
11472         let pattern3_0 = arg2;
11473         // Rule at src/isa/x64/lower.isle line 1196.
11474         let expr0_0 = constructor_x64_pandn(ctx, pattern2_0, pattern3_0)?;
11475         return Some(expr0_0);
11476     }
11477     return None;
11478 }
11479 
11480 // Generated as internal constructor for term i128_not.
11481 pub fn constructor_i128_not<C: Context>(ctx: &mut C, arg0: Value) -> Option<ValueRegs> {
11482     let pattern0_0 = arg0;
11483     // Rule at src/isa/x64/lower.isle line 1259.
11484     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
11485     let expr1_0: usize = 0;
11486     let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
11487     let expr3_0: usize = 1;
11488     let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
11489     let expr5_0: Type = I64;
11490     let expr6_0 = constructor_x64_not(ctx, expr5_0, expr2_0)?;
11491     let expr7_0: Type = I64;
11492     let expr8_0 = constructor_x64_not(ctx, expr7_0, expr4_0)?;
11493     let expr9_0 = constructor_value_gprs(ctx, expr6_0, expr8_0)?;
11494     return Some(expr9_0);
11495 }
11496 
11497 // Generated as internal constructor for term vec_insert_lane.
11498 pub fn constructor_vec_insert_lane<C: Context>(
11499     ctx: &mut C,
11500     arg0: Type,
11501     arg1: Xmm,
11502     arg2: &RegMem,
11503     arg3: u8,
11504 ) -> Option<Xmm> {
11505     let pattern0_0 = arg0;
11506     if pattern0_0 == I8X16 {
11507         let pattern2_0 = arg1;
11508         let pattern3_0 = arg2;
11509         let pattern4_0 = arg3;
11510         // Rule at src/isa/x64/lower.isle line 1313.
11511         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
11512         let expr1_0 = constructor_x64_pinsrb(ctx, pattern2_0, &expr0_0, pattern4_0)?;
11513         return Some(expr1_0);
11514     }
11515     if pattern0_0 == I16X8 {
11516         let pattern2_0 = arg1;
11517         let pattern3_0 = arg2;
11518         let pattern4_0 = arg3;
11519         // Rule at src/isa/x64/lower.isle line 1317.
11520         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
11521         let expr1_0 = constructor_x64_pinsrw(ctx, pattern2_0, &expr0_0, pattern4_0)?;
11522         return Some(expr1_0);
11523     }
11524     if pattern0_0 == I32X4 {
11525         let pattern2_0 = arg1;
11526         let pattern3_0 = arg2;
11527         let pattern4_0 = arg3;
11528         // Rule at src/isa/x64/lower.isle line 1321.
11529         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
11530         let expr1_0 = OperandSize::Size32;
11531         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
11532         return Some(expr2_0);
11533     }
11534     if pattern0_0 == I64X2 {
11535         let pattern2_0 = arg1;
11536         let pattern3_0 = arg2;
11537         let pattern4_0 = arg3;
11538         // Rule at src/isa/x64/lower.isle line 1325.
11539         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
11540         let expr1_0 = OperandSize::Size64;
11541         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
11542         return Some(expr2_0);
11543     }
11544     if pattern0_0 == F32X4 {
11545         let pattern2_0 = arg1;
11546         let pattern3_0 = arg2;
11547         let pattern4_0 = arg3;
11548         // Rule at src/isa/x64/lower.isle line 1329.
11549         let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
11550         let expr1_0 = C::sse_insertps_lane_imm(ctx, pattern4_0);
11551         let expr2_0 = constructor_x64_insertps(ctx, pattern2_0, &expr0_0, expr1_0)?;
11552         return Some(expr2_0);
11553     }
11554     if pattern0_0 == F64X2 {
11555         let pattern2_0 = arg1;
11556         let pattern3_0 = arg2;
11557         if let &RegMem::Reg { reg: pattern4_0 } = pattern3_0 {
11558             let pattern5_0 = arg3;
11559             if pattern5_0 == 0 {
11560                 // Rule at src/isa/x64/lower.isle line 1351.
11561                 let expr0_0 = constructor_reg_to_xmm_mem(ctx, pattern4_0)?;
11562                 let expr1_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr0_0)?;
11563                 return Some(expr1_0);
11564             }
11565         }
11566         let pattern4_0 = arg3;
11567         if pattern4_0 == 0 {
11568             // Rule at src/isa/x64/lower.isle line 1353.
11569             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
11570             let expr1_0 = constructor_x64_movsd_load(ctx, &expr0_0)?;
11571             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
11572             let expr3_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr2_0)?;
11573             return Some(expr3_0);
11574         }
11575         if pattern4_0 == 1 {
11576             // Rule at src/isa/x64/lower.isle line 1361.
11577             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
11578             let expr1_0 = constructor_x64_movlhps(ctx, pattern2_0, &expr0_0)?;
11579             return Some(expr1_0);
11580         }
11581     }
11582     return None;
11583 }
11584 
11585 // Generated as internal constructor for term cmp_and_choose.
11586 pub fn constructor_cmp_and_choose<C: Context>(
11587     ctx: &mut C,
11588     arg0: Type,
11589     arg1: &CC,
11590     arg2: Value,
11591     arg3: Value,
11592 ) -> Option<ValueRegs> {
11593     let pattern0_0 = arg0;
11594     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
11595         let pattern2_0 = arg1;
11596         let pattern3_0 = arg2;
11597         let pattern4_0 = arg3;
11598         // Rule at src/isa/x64/lower.isle line 1369.
11599         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern1_0);
11600         let expr1_0 = C::put_in_reg(ctx, pattern3_0);
11601         let expr2_0 = C::put_in_reg(ctx, pattern4_0);
11602         let expr3_0 = constructor_reg_to_gpr_mem_imm(ctx, expr1_0)?;
11603         let expr4_0 = C::gpr_new(ctx, expr2_0);
11604         let expr5_0 = constructor_x64_cmp(ctx, &expr0_0, &expr3_0, expr4_0)?;
11605         let expr6_0 = C::reg_to_gpr_mem(ctx, expr2_0);
11606         let expr7_0 = C::gpr_new(ctx, expr1_0);
11607         let expr8_0 = constructor_cmove(ctx, pattern1_0, pattern2_0, &expr6_0, expr7_0)?;
11608         let expr9_0 = constructor_with_flags_reg(ctx, &expr5_0, &expr8_0)?;
11609         let expr10_0 = C::value_reg(ctx, expr9_0);
11610         return Some(expr10_0);
11611     }
11612     return None;
11613 }
11614 
11615 // Generated as internal constructor for term do_clz.
11616 pub fn constructor_do_clz<C: Context>(
11617     ctx: &mut C,
11618     arg0: Type,
11619     arg1: Type,
11620     arg2: Gpr,
11621 ) -> Option<Gpr> {
11622     let pattern0_0 = arg0;
11623     let pattern1_0 = arg1;
11624     let pattern2_0 = arg2;
11625     // Rule at src/isa/x64/lower.isle line 1816.
11626     let expr0_0: Type = I64;
11627     let expr1_0: i64 = -1;
11628     let expr2_0 = constructor_imm_i64(ctx, expr0_0, expr1_0)?;
11629     let expr3_0 = C::gpr_new(ctx, expr2_0);
11630     let expr4_0 = constructor_bsr_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
11631     let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
11632     let expr6_0 = C::ty_bits_u64(ctx, pattern1_0);
11633     let expr7_0: u64 = 1;
11634     let expr8_0 = C::u64_sub(ctx, expr6_0, expr7_0);
11635     let expr9_0 = constructor_imm(ctx, pattern0_0, expr8_0)?;
11636     let expr10_0 = C::gpr_new(ctx, expr9_0);
11637     let expr11_0 = constructor_reg_to_gpr_mem_imm(ctx, expr5_0)?;
11638     let expr12_0 = constructor_x64_sub(ctx, pattern0_0, expr10_0, &expr11_0)?;
11639     return Some(expr12_0);
11640 }
11641 
11642 // Generated as internal constructor for term do_ctz.
11643 pub fn constructor_do_ctz<C: Context>(
11644     ctx: &mut C,
11645     arg0: Type,
11646     arg1: Type,
11647     arg2: Gpr,
11648 ) -> Option<Gpr> {
11649     let pattern0_0 = arg0;
11650     let pattern1_0 = arg1;
11651     let pattern2_0 = arg2;
11652     // Rule at src/isa/x64/lower.isle line 1857.
11653     let expr0_0: Type = I64;
11654     let expr1_0 = C::ty_bits_u64(ctx, pattern1_0);
11655     let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
11656     let expr3_0 = C::gpr_new(ctx, expr2_0);
11657     let expr4_0 = constructor_bsf_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
11658     return Some(expr4_0);
11659 }
11660 
11661 // Generated as internal constructor for term do_popcnt.
11662 pub fn constructor_do_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11663     let pattern0_0 = arg0;
11664     if pattern0_0 == I32 {
11665         let pattern2_0 = arg1;
11666         // Rule at src/isa/x64/lower.isle line 1948.
11667         let expr0_0: Type = I32;
11668         let expr1_0: u8 = 1;
11669         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
11670         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
11671         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
11672         let expr5_0: Type = I32;
11673         let expr6_0: u64 = 2004318071;
11674         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
11675         let expr8_0 = C::gpr_new(ctx, expr7_0);
11676         let expr9_0: Type = I32;
11677         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
11678         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
11679         let expr12_0: Type = I32;
11680         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
11681         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
11682         let expr15_0: Type = I32;
11683         let expr16_0: u8 = 1;
11684         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
11685         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
11686         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
11687         let expr20_0: Type = I32;
11688         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
11689         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
11690         let expr23_0: Type = I32;
11691         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
11692         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
11693         let expr26_0: Type = I32;
11694         let expr27_0: u8 = 1;
11695         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
11696         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
11697         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
11698         let expr31_0: Type = I32;
11699         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
11700         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
11701         let expr34_0: Type = I32;
11702         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
11703         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
11704         let expr37_0: Type = I32;
11705         let expr38_0: Type = I32;
11706         let expr39_0: u8 = 4;
11707         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
11708         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
11709         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
11710         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
11711         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
11712         let expr45_0: Type = I32;
11713         let expr46_0: u32 = 252645135;
11714         let expr47_0 = RegMemImm::Imm { simm32: expr46_0 };
11715         let expr48_0 = C::gpr_mem_imm_new(ctx, &expr47_0);
11716         let expr49_0 = constructor_x64_and(ctx, expr45_0, expr44_0, &expr48_0)?;
11717         let expr50_0: Type = I32;
11718         let expr51_0: u32 = 16843009;
11719         let expr52_0 = RegMemImm::Imm { simm32: expr51_0 };
11720         let expr53_0 = C::gpr_mem_imm_new(ctx, &expr52_0);
11721         let expr54_0 = constructor_x64_mul(ctx, expr50_0, expr49_0, &expr53_0)?;
11722         let expr55_0: Type = I32;
11723         let expr56_0: u8 = 24;
11724         let expr57_0 = Imm8Reg::Imm8 { imm: expr56_0 };
11725         let expr58_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr57_0);
11726         let expr59_0 = constructor_x64_shr(ctx, expr55_0, expr54_0, &expr58_0)?;
11727         return Some(expr59_0);
11728     }
11729     if pattern0_0 == I64 {
11730         let pattern2_0 = arg1;
11731         // Rule at src/isa/x64/lower.isle line 1905.
11732         let expr0_0: Type = I64;
11733         let expr1_0: u8 = 1;
11734         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
11735         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
11736         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
11737         let expr5_0: Type = I64;
11738         let expr6_0: u64 = 8608480567731124087;
11739         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
11740         let expr8_0 = C::gpr_new(ctx, expr7_0);
11741         let expr9_0: Type = I64;
11742         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
11743         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
11744         let expr12_0: Type = I64;
11745         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
11746         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
11747         let expr15_0: Type = I64;
11748         let expr16_0: u8 = 1;
11749         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
11750         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
11751         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
11752         let expr20_0: Type = I64;
11753         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
11754         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
11755         let expr23_0: Type = I64;
11756         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
11757         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
11758         let expr26_0: Type = I64;
11759         let expr27_0: u8 = 1;
11760         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
11761         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
11762         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
11763         let expr31_0: Type = I64;
11764         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
11765         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
11766         let expr34_0: Type = I64;
11767         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
11768         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
11769         let expr37_0: Type = I64;
11770         let expr38_0: Type = I64;
11771         let expr39_0: u8 = 4;
11772         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
11773         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
11774         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
11775         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
11776         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
11777         let expr45_0: Type = I64;
11778         let expr46_0: u64 = 1085102592571150095;
11779         let expr47_0 = constructor_imm(ctx, expr45_0, expr46_0)?;
11780         let expr48_0 = C::gpr_new(ctx, expr47_0);
11781         let expr49_0: Type = I64;
11782         let expr50_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
11783         let expr51_0 = constructor_x64_and(ctx, expr49_0, expr44_0, &expr50_0)?;
11784         let expr52_0: Type = I64;
11785         let expr53_0: u64 = 72340172838076673;
11786         let expr54_0 = constructor_imm(ctx, expr52_0, expr53_0)?;
11787         let expr55_0 = C::gpr_new(ctx, expr54_0);
11788         let expr56_0: Type = I64;
11789         let expr57_0 = C::gpr_to_gpr_mem_imm(ctx, expr55_0);
11790         let expr58_0 = constructor_x64_mul(ctx, expr56_0, expr51_0, &expr57_0)?;
11791         let expr59_0: Type = I64;
11792         let expr60_0: u8 = 56;
11793         let expr61_0 = Imm8Reg::Imm8 { imm: expr60_0 };
11794         let expr62_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr61_0);
11795         let expr63_0 = constructor_x64_shr(ctx, expr59_0, expr58_0, &expr62_0)?;
11796         return Some(expr63_0);
11797     }
11798     return None;
11799 }
11800 
11801 // Generated as internal constructor for term do_bitrev8.
11802 pub fn constructor_do_bitrev8<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11803     let pattern0_0 = arg0;
11804     let pattern1_0 = arg1;
11805     // Rule at src/isa/x64/lower.isle line 2037.
11806     let expr0_0 = C::ty_mask(ctx, pattern0_0);
11807     let expr1_0: u64 = 6148914691236517205;
11808     let expr2_0 = C::u64_and(ctx, expr0_0, expr1_0);
11809     let expr3_0 = constructor_imm(ctx, pattern0_0, expr2_0)?;
11810     let expr4_0 = C::gpr_new(ctx, expr3_0);
11811     let expr5_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
11812     let expr6_0 = constructor_x64_and(ctx, pattern0_0, pattern1_0, &expr5_0)?;
11813     let expr7_0: u8 = 1;
11814     let expr8_0 = Imm8Reg::Imm8 { imm: expr7_0 };
11815     let expr9_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr8_0);
11816     let expr10_0 = constructor_x64_shr(ctx, pattern0_0, pattern1_0, &expr9_0)?;
11817     let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
11818     let expr12_0 = constructor_x64_and(ctx, pattern0_0, expr10_0, &expr11_0)?;
11819     let expr13_0: u8 = 1;
11820     let expr14_0 = Imm8Reg::Imm8 { imm: expr13_0 };
11821     let expr15_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr14_0);
11822     let expr16_0 = constructor_x64_shl(ctx, pattern0_0, expr6_0, &expr15_0)?;
11823     let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr12_0);
11824     let expr18_0 = constructor_x64_or(ctx, pattern0_0, expr16_0, &expr17_0)?;
11825     let expr19_0: u64 = 3689348814741910323;
11826     let expr20_0 = C::u64_and(ctx, expr0_0, expr19_0);
11827     let expr21_0 = constructor_imm(ctx, pattern0_0, expr20_0)?;
11828     let expr22_0 = C::gpr_new(ctx, expr21_0);
11829     let expr23_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
11830     let expr24_0 = constructor_x64_and(ctx, pattern0_0, expr18_0, &expr23_0)?;
11831     let expr25_0: u8 = 2;
11832     let expr26_0 = Imm8Reg::Imm8 { imm: expr25_0 };
11833     let expr27_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr26_0);
11834     let expr28_0 = constructor_x64_shr(ctx, pattern0_0, expr18_0, &expr27_0)?;
11835     let expr29_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
11836     let expr30_0 = constructor_x64_and(ctx, pattern0_0, expr28_0, &expr29_0)?;
11837     let expr31_0: u8 = 2;
11838     let expr32_0 = Imm8Reg::Imm8 { imm: expr31_0 };
11839     let expr33_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr32_0);
11840     let expr34_0 = constructor_x64_shl(ctx, pattern0_0, expr24_0, &expr33_0)?;
11841     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr30_0);
11842     let expr36_0 = constructor_x64_or(ctx, pattern0_0, expr34_0, &expr35_0)?;
11843     let expr37_0: u64 = 1085102592571150095;
11844     let expr38_0 = C::u64_and(ctx, expr0_0, expr37_0);
11845     let expr39_0 = constructor_imm(ctx, pattern0_0, expr38_0)?;
11846     let expr40_0 = C::gpr_new(ctx, expr39_0);
11847     let expr41_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
11848     let expr42_0 = constructor_x64_and(ctx, pattern0_0, expr36_0, &expr41_0)?;
11849     let expr43_0: u8 = 4;
11850     let expr44_0 = Imm8Reg::Imm8 { imm: expr43_0 };
11851     let expr45_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr44_0);
11852     let expr46_0 = constructor_x64_shr(ctx, pattern0_0, expr36_0, &expr45_0)?;
11853     let expr47_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
11854     let expr48_0 = constructor_x64_and(ctx, pattern0_0, expr46_0, &expr47_0)?;
11855     let expr49_0: u8 = 4;
11856     let expr50_0 = Imm8Reg::Imm8 { imm: expr49_0 };
11857     let expr51_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr50_0);
11858     let expr52_0 = constructor_x64_shl(ctx, pattern0_0, expr42_0, &expr51_0)?;
11859     let expr53_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
11860     let expr54_0 = constructor_x64_or(ctx, pattern0_0, expr52_0, &expr53_0)?;
11861     return Some(expr54_0);
11862 }
11863 
11864 // Generated as internal constructor for term do_bitrev16.
11865 pub fn constructor_do_bitrev16<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11866     let pattern0_0 = arg0;
11867     let pattern1_0 = arg1;
11868     // Rule at src/isa/x64/lower.isle line 2060.
11869     let expr0_0 = constructor_do_bitrev8(ctx, pattern0_0, pattern1_0)?;
11870     let expr1_0 = C::ty_mask(ctx, pattern0_0);
11871     let expr2_0: u64 = 71777214294589695;
11872     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0);
11873     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
11874     let expr5_0 = C::gpr_new(ctx, expr4_0);
11875     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11876     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
11877     let expr8_0: u8 = 8;
11878     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
11879     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
11880     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
11881     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11882     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
11883     let expr14_0: u8 = 8;
11884     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
11885     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
11886     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
11887     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
11888     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
11889     return Some(expr19_0);
11890 }
11891 
11892 // Generated as internal constructor for term do_bitrev32.
11893 pub fn constructor_do_bitrev32<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11894     let pattern0_0 = arg0;
11895     let pattern1_0 = arg1;
11896     // Rule at src/isa/x64/lower.isle line 2072.
11897     let expr0_0 = constructor_do_bitrev16(ctx, pattern0_0, pattern1_0)?;
11898     let expr1_0 = C::ty_mask(ctx, pattern0_0);
11899     let expr2_0: u64 = 281470681808895;
11900     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0);
11901     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
11902     let expr5_0 = C::gpr_new(ctx, expr4_0);
11903     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11904     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
11905     let expr8_0: u8 = 16;
11906     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
11907     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
11908     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
11909     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11910     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
11911     let expr14_0: u8 = 16;
11912     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
11913     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
11914     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
11915     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
11916     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
11917     return Some(expr19_0);
11918 }
11919 
11920 // Generated as internal constructor for term do_bitrev64.
11921 pub fn constructor_do_bitrev64<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11922     let pattern0_0 = arg0;
11923     if pattern0_0 == I64 {
11924         let pattern2_0 = arg1;
11925         // Rule at src/isa/x64/lower.isle line 2084.
11926         let expr0_0 = constructor_do_bitrev32(ctx, pattern0_0, pattern2_0)?;
11927         let expr1_0: u64 = 4294967295;
11928         let expr2_0 = constructor_imm(ctx, pattern0_0, expr1_0)?;
11929         let expr3_0 = C::gpr_new(ctx, expr2_0);
11930         let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr3_0);
11931         let expr5_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr4_0)?;
11932         let expr6_0: u8 = 32;
11933         let expr7_0 = Imm8Reg::Imm8 { imm: expr6_0 };
11934         let expr8_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr7_0);
11935         let expr9_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr8_0)?;
11936         let expr10_0: u8 = 32;
11937         let expr11_0 = Imm8Reg::Imm8 { imm: expr10_0 };
11938         let expr12_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr11_0);
11939         let expr13_0 = constructor_x64_shl(ctx, pattern0_0, expr5_0, &expr12_0)?;
11940         let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
11941         let expr15_0 = constructor_x64_or(ctx, pattern0_0, expr13_0, &expr14_0)?;
11942         return Some(expr15_0);
11943     }
11944     return None;
11945 }
11946 
11947 // Generated as internal constructor for term generic_sextend.
11948 pub fn constructor_generic_sextend<C: Context>(
11949     ctx: &mut C,
11950     arg0: Value,
11951     arg1: Type,
11952     arg2: Type,
11953 ) -> Option<InstOutput> {
11954     let pattern0_0 = arg0;
11955     let pattern1_0 = arg1;
11956     if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) {
11957         let pattern3_0 = arg2;
11958         if let Some(pattern4_0) = C::fits_in_32(ctx, pattern3_0) {
11959             // Rule at src/isa/x64/lower.isle line 2204.
11960             let expr0_0: Type = I32;
11961             let expr1_0 = ExtendKind::Sign;
11962             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11963             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11964             return Some(expr3_0);
11965         }
11966         if let Some(pattern4_0) = C::ty_int_bool_64(ctx, pattern3_0) {
11967             // Rule at src/isa/x64/lower.isle line 2200.
11968             let expr0_0: Type = I64;
11969             let expr1_0 = ExtendKind::Sign;
11970             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11971             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11972             return Some(expr3_0);
11973         }
11974         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
11975             // Rule at src/isa/x64/lower.isle line 2194.
11976             let expr0_0: Type = I64;
11977             let expr1_0 = ExtendKind::Sign;
11978             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11979             let expr3_0 = constructor_spread_sign_bit(ctx, expr2_0)?;
11980             let expr4_0 = C::gpr_to_reg(ctx, expr2_0);
11981             let expr5_0 = C::gpr_to_reg(ctx, expr3_0);
11982             let expr6_0 = C::value_regs(ctx, expr4_0, expr5_0);
11983             let expr7_0 = C::output(ctx, expr6_0);
11984             return Some(expr7_0);
11985         }
11986     }
11987     if let Some(pattern2_0) = C::ty_int_bool_64(ctx, pattern1_0) {
11988         let pattern3_0 = arg2;
11989         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
11990             // Rule at src/isa/x64/lower.isle line 2190.
11991             let expr0_0 = C::put_in_reg(ctx, pattern0_0);
11992             let expr1_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
11993             let expr2_0 = constructor_spread_sign_bit(ctx, expr1_0)?;
11994             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
11995             let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
11996             let expr5_0 = C::output(ctx, expr4_0);
11997             return Some(expr5_0);
11998         }
11999     }
12000     let pattern2_0 = arg2;
12001     if pattern2_0 == pattern1_0 {
12002         // Rule at src/isa/x64/lower.isle line 2180.
12003         let expr0_0 = constructor_output_value(ctx, pattern0_0)?;
12004         return Some(expr0_0);
12005     }
12006     return None;
12007 }
12008 
12009 // Generated as internal constructor for term spread_sign_bit.
12010 pub fn constructor_spread_sign_bit<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<Gpr> {
12011     let pattern0_0 = arg0;
12012     // Rule at src/isa/x64/lower.isle line 2186.
12013     let expr0_0: Type = I64;
12014     let expr1_0: u8 = 63;
12015     let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
12016     let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
12017     let expr4_0 = constructor_x64_sar(ctx, expr0_0, pattern0_0, &expr3_0)?;
12018     return Some(expr4_0);
12019 }
12020