// license that can be found in the LICENSE file.
// Lowering arithmetic
-(Add(64|32|16|8|Ptr) x y) -> (I64Add x y)
-(Add(64|32)F x y) -> (F(64|32)Add x y)
+(Add(64|32|16|8|Ptr) ...) -> (I64Add ...)
+(Add(64|32)F ...) -> (F(64|32)Add ...)
-(Sub(64|32|16|8|Ptr) x y) -> (I64Sub x y)
-(Sub(64|32)F x y) -> (F(64|32)Sub x y)
+(Sub(64|32|16|8|Ptr) ...) -> (I64Sub ...)
+(Sub(64|32)F ...) -> (F(64|32)Sub ...)
-(Mul(64|32|16|8) x y) -> (I64Mul x y)
-(Mul(64|32)F x y) -> (F(64|32)Mul x y)
+(Mul(64|32|16|8) ...) -> (I64Mul ...)
+(Mul(64|32)F ...) -> (F(64|32)Mul ...)
-(Div64 x y) -> (I64DivS x y)
-(Div64u x y) -> (I64DivU x y)
+(Div64 [a] x y) -> (I64DivS x y)
+(Div64u ...) -> (I64DivU ...)
(Div32 x y) -> (I64DivS (SignExt32to64 x) (SignExt32to64 y))
(Div32u x y) -> (I64DivU (ZeroExt32to64 x) (ZeroExt32to64 y))
(Div16 x y) -> (I64DivS (SignExt16to64 x) (SignExt16to64 y))
(Div16u x y) -> (I64DivU (ZeroExt16to64 x) (ZeroExt16to64 y))
(Div8 x y) -> (I64DivS (SignExt8to64 x) (SignExt8to64 y))
(Div8u x y) -> (I64DivU (ZeroExt8to64 x) (ZeroExt8to64 y))
-(Div(64|32)F x y) -> (F(64|32)Div x y)
+(Div(64|32)F ...) -> (F(64|32)Div ...)
-(Mod64 x y) -> (I64RemS x y)
-(Mod64u x y) -> (I64RemU x y)
+(Mod64 [a] x y) -> (I64RemS x y)
+(Mod64u ...) -> (I64RemU ...)
(Mod32 x y) -> (I64RemS (SignExt32to64 x) (SignExt32to64 y))
(Mod32u x y) -> (I64RemU (ZeroExt32to64 x) (ZeroExt32to64 y))
(Mod16 x y) -> (I64RemS (SignExt16to64 x) (SignExt16to64 y))
(Mod8 x y) -> (I64RemS (SignExt8to64 x) (SignExt8to64 y))
(Mod8u x y) -> (I64RemU (ZeroExt8to64 x) (ZeroExt8to64 y))
-(And(64|32|16|8|B) x y) -> (I64And x y)
+(And(64|32|16|8|B) ...) -> (I64And ...)
-(Or(64|32|16|8|B) x y) -> (I64Or x y)
+(Or(64|32|16|8|B) ...) -> (I64Or ...)
-(Xor(64|32|16|8) x y) -> (I64Xor x y)
+(Xor(64|32|16|8) ...) -> (I64Xor ...)
(Neg(64|32|16|8) x) -> (I64Sub (I64Const [0]) x)
-(Neg(64|32)F x) -> (F(64|32)Neg x)
+(Neg(64|32)F ...) -> (F(64|32)Neg ...)
(Com(64|32|16|8) x) -> (I64Xor x (I64Const [-1]))
-(Not x) -> (I64Eqz x)
+(Not ...) -> (I64Eqz ...)
// Lowering pointer arithmetic
-(OffPtr [off] ptr) -> (I64AddConst [off] ptr)
+(OffPtr ...) -> (I64AddConst ...)
// Lowering extension
// It is unnecessary to extend loads
// Lowering truncation
// Because we ignore the high parts, truncates are just copies.
-(Trunc64to(32|16|8) x) -> x
-(Trunc32to(16|8) x) -> x
-(Trunc16to8 x) -> x
+(Trunc64to(32|16|8) ...) -> (Copy ...)
+(Trunc32to(16|8) ...) -> (Copy ...)
+(Trunc16to8 ...) -> (Copy ...)
// Lowering float <-> int
(Cvt32to(64|32)F x) -> (F(64|32)ConvertI64S (SignExt32to64 x))
-(Cvt64to(64|32)F x) -> (F(64|32)ConvertI64S x)
+(Cvt64to(64|32)F ...) -> (F(64|32)ConvertI64S ...)
(Cvt32Uto(64|32)F x) -> (F(64|32)ConvertI64U (ZeroExt32to64 x))
-(Cvt64Uto(64|32)F x) -> (F(64|32)ConvertI64U x)
+(Cvt64Uto(64|32)F ...) -> (F(64|32)ConvertI64U ...)
-(Cvt32Fto32 x) -> (I64TruncSatF32S x)
-(Cvt32Fto64 x) -> (I64TruncSatF32S x)
-(Cvt64Fto32 x) -> (I64TruncSatF64S x)
-(Cvt64Fto64 x) -> (I64TruncSatF64S x)
-(Cvt32Fto32U x) -> (I64TruncSatF32U x)
-(Cvt32Fto64U x) -> (I64TruncSatF32U x)
-(Cvt64Fto32U x) -> (I64TruncSatF64U x)
-(Cvt64Fto64U x) -> (I64TruncSatF64U x)
+(Cvt32Fto32 ...) -> (I64TruncSatF32S ...)
+(Cvt32Fto64 ...) -> (I64TruncSatF32S ...)
+(Cvt64Fto32 ...) -> (I64TruncSatF64S ...)
+(Cvt64Fto64 ...) -> (I64TruncSatF64S ...)
+(Cvt32Fto32U ...) -> (I64TruncSatF32U ...)
+(Cvt32Fto64U ...) -> (I64TruncSatF32U ...)
+(Cvt64Fto32U ...) -> (I64TruncSatF64U ...)
+(Cvt64Fto64U ...) -> (I64TruncSatF64U ...)
-(Cvt32Fto64F x) -> (F64PromoteF32 x)
-(Cvt64Fto32F x) -> (F32DemoteF64 x)
+(Cvt32Fto64F ...) -> (F64PromoteF32 ...)
+(Cvt64Fto32F ...) -> (F32DemoteF64 ...)
-(Round32F x) -> x
-(Round64F x) -> x
+(Round32F ...) -> (Copy ...)
+(Round64F ...) -> (Copy ...)
// Lowering shifts
// Unsigned shifts need to return 0 if shift amount is >= width of shifted value.
(Lsh64x64 x y) -> (Select (I64Shl x y) (I64Const [0]) (I64LtU y (I64Const [64])))
(Lsh64x(32|16|8) [c] x y) -> (Lsh64x64 [c] x (ZeroExt(32|16|8)to64 y))
-(Lsh32x64 [c] x y) -> (Lsh64x64 [c] x y)
+(Lsh32x64 ...) -> (Lsh64x64 ...)
(Lsh32x(32|16|8) [c] x y) -> (Lsh64x64 [c] x (ZeroExt(32|16|8)to64 y))
-(Lsh16x64 [c] x y) -> (Lsh64x64 [c] x y)
+(Lsh16x64 ...) -> (Lsh64x64 ...)
(Lsh16x(32|16|8) [c] x y) -> (Lsh64x64 [c] x (ZeroExt(32|16|8)to64 y))
-(Lsh8x64 [c] x y) -> (Lsh64x64 [c] x y)
+(Lsh8x64 ...) -> (Lsh64x64 ...)
(Lsh8x(32|16|8) [c] x y) -> (Lsh64x64 [c] x (ZeroExt(32|16|8)to64 y))
(Rsh64Ux64 x y) && shiftIsBounded(v) -> (I64ShrU x y)
// Lowering rotates
(RotateLeft8 <t> x (I64Const [c])) -> (Or8 (Lsh8x64 <t> x (I64Const [c&7])) (Rsh8Ux64 <t> x (I64Const [-c&7])))
(RotateLeft16 <t> x (I64Const [c])) -> (Or16 (Lsh16x64 <t> x (I64Const [c&15])) (Rsh16Ux64 <t> x (I64Const [-c&15])))
-(RotateLeft32 x y) -> (I32Rotl x y)
-(RotateLeft64 x y) -> (I64Rotl x y)
+(RotateLeft32 ...) -> (I32Rotl ...)
+(RotateLeft64 ...) -> (I64Rotl ...)
// Lowering comparisons
-(Less64 x y) -> (I64LtS x y)
+(Less64 ...) -> (I64LtS ...)
(Less32 x y) -> (I64LtS (SignExt32to64 x) (SignExt32to64 y))
(Less16 x y) -> (I64LtS (SignExt16to64 x) (SignExt16to64 y))
(Less8 x y) -> (I64LtS (SignExt8to64 x) (SignExt8to64 y))
-(Less64U x y) -> (I64LtU x y)
+(Less64U ...) -> (I64LtU ...)
(Less32U x y) -> (I64LtU (ZeroExt32to64 x) (ZeroExt32to64 y))
(Less16U x y) -> (I64LtU (ZeroExt16to64 x) (ZeroExt16to64 y))
(Less8U x y) -> (I64LtU (ZeroExt8to64 x) (ZeroExt8to64 y))
-(Less(64|32)F x y) -> (F(64|32)Lt x y)
+(Less(64|32)F ...) -> (F(64|32)Lt ...)
-(Leq64 x y) -> (I64LeS x y)
+(Leq64 ...) -> (I64LeS ...)
(Leq32 x y) -> (I64LeS (SignExt32to64 x) (SignExt32to64 y))
(Leq16 x y) -> (I64LeS (SignExt16to64 x) (SignExt16to64 y))
(Leq8 x y) -> (I64LeS (SignExt8to64 x) (SignExt8to64 y))
-(Leq64U x y) -> (I64LeU x y)
+(Leq64U ...) -> (I64LeU ...)
(Leq32U x y) -> (I64LeU (ZeroExt32to64 x) (ZeroExt32to64 y))
(Leq16U x y) -> (I64LeU (ZeroExt16to64 x) (ZeroExt16to64 y))
(Leq8U x y) -> (I64LeU (ZeroExt8to64 x) (ZeroExt8to64 y))
-(Leq(64|32)F x y) -> (F(64|32)Le x y)
+(Leq(64|32)F ...) -> (F(64|32)Le ...)
-(Greater64 x y) -> (I64GtS x y)
+(Greater64 ...) -> (I64GtS ...)
(Greater32 x y) -> (I64GtS (SignExt32to64 x) (SignExt32to64 y))
(Greater16 x y) -> (I64GtS (SignExt16to64 x) (SignExt16to64 y))
(Greater8 x y) -> (I64GtS (SignExt8to64 x) (SignExt8to64 y))
-(Greater64U x y) -> (I64GtU x y)
+(Greater64U ...) -> (I64GtU ...)
(Greater32U x y) -> (I64GtU (ZeroExt32to64 x) (ZeroExt32to64 y))
(Greater16U x y) -> (I64GtU (ZeroExt16to64 x) (ZeroExt16to64 y))
(Greater8U x y) -> (I64GtU (ZeroExt8to64 x) (ZeroExt8to64 y))
-(Greater(64|32)F x y) -> (F(64|32)Gt x y)
+(Greater(64|32)F ...) -> (F(64|32)Gt ...)
-(Geq64 x y) -> (I64GeS x y)
+(Geq64 ...) -> (I64GeS ...)
(Geq32 x y) -> (I64GeS (SignExt32to64 x) (SignExt32to64 y))
(Geq16 x y) -> (I64GeS (SignExt16to64 x) (SignExt16to64 y))
(Geq8 x y) -> (I64GeS (SignExt8to64 x) (SignExt8to64 y))
-(Geq64U x y) -> (I64GeU x y)
+(Geq64U ...) -> (I64GeU ...)
(Geq32U x y) -> (I64GeU (ZeroExt32to64 x) (ZeroExt32to64 y))
(Geq16U x y) -> (I64GeU (ZeroExt16to64 x) (ZeroExt16to64 y))
(Geq8U x y) -> (I64GeU (ZeroExt8to64 x) (ZeroExt8to64 y))
-(Geq(64|32)F x y) -> (F(64|32)Ge x y)
+(Geq(64|32)F ...) -> (F(64|32)Ge ...)
-(Eq64 x y) -> (I64Eq x y)
+(Eq64 ...) -> (I64Eq ...)
(Eq32 x y) -> (I64Eq (ZeroExt32to64 x) (ZeroExt32to64 y))
(Eq16 x y) -> (I64Eq (ZeroExt16to64 x) (ZeroExt16to64 y))
(Eq8 x y) -> (I64Eq (ZeroExt8to64 x) (ZeroExt8to64 y))
-(EqB x y) -> (I64Eq x y)
-(EqPtr x y) -> (I64Eq x y)
-(Eq(64|32)F x y) -> (F(64|32)Eq x y)
+(EqB ...) -> (I64Eq ...)
+(EqPtr ...) -> (I64Eq ...)
+(Eq(64|32)F ...) -> (F(64|32)Eq ...)
-(Neq64 x y) -> (I64Ne x y)
+(Neq64 ...) -> (I64Ne ...)
(Neq32 x y) -> (I64Ne (ZeroExt32to64 x) (ZeroExt32to64 y))
(Neq16 x y) -> (I64Ne (ZeroExt16to64 x) (ZeroExt16to64 y))
(Neq8 x y) -> (I64Ne (ZeroExt8to64 x) (ZeroExt8to64 y))
-(NeqB x y) -> (I64Ne x y)
-(NeqPtr x y) -> (I64Ne x y)
-(Neq(64|32)F x y) -> (F(64|32)Ne x y)
+(NeqB ...) -> (I64Ne ...)
+(NeqPtr ...) -> (I64Ne ...)
+(Neq(64|32)F ...) -> (F(64|32)Ne ...)
// Lowering loads
(Load <t> ptr mem) && is32BitFloat(t) -> (F32Load ptr mem)
(LoweredZero [s/8] destptr mem)
// Lowering constants
-(Const(64|32|16|8) [val]) -> (I64Const [val])
-(Const(64|32)F [val]) -> (F(64|32)Const [val])
+(Const(64|32|16|8) ...) -> (I64Const ...)
+(Const(64|32)F ...) -> (F(64|32)Const ...)
(ConstNil) -> (I64Const [0])
-(ConstBool [b]) -> (I64Const [b])
+(ConstBool ...) -> (I64Const ...)
// Lowering calls
-(StaticCall [argwid] {target} mem) -> (LoweredStaticCall [argwid] {target} mem)
-(ClosureCall [argwid] entry closure mem) -> (LoweredClosureCall [argwid] entry closure mem)
-(InterCall [argwid] entry mem) -> (LoweredInterCall [argwid] entry mem)
+(StaticCall ...) -> (LoweredStaticCall ...)
+(ClosureCall ...) -> (LoweredClosureCall ...)
+(InterCall ...) -> (LoweredInterCall ...)
// Miscellaneous
-(Convert <t> x mem) -> (LoweredConvert <t> x mem)
+(Convert ...) -> (LoweredConvert ...)
(IsNonNil p) -> (I64Eqz (I64Eqz p))
-(IsInBounds idx len) -> (I64LtU idx len)
-(IsSliceInBounds idx len) -> (I64LeU idx len)
-(NilCheck ptr mem) -> (LoweredNilCheck ptr mem)
-(GetClosurePtr) -> (LoweredGetClosurePtr)
-(GetCallerPC) -> (LoweredGetCallerPC)
-(GetCallerSP) -> (LoweredGetCallerSP)
-(Addr {sym} base) -> (LoweredAddr {sym} base)
+(IsInBounds ...) -> (I64LtU ...)
+(IsSliceInBounds ...) -> (I64LeU ...)
+(NilCheck ...) -> (LoweredNilCheck ...)
+(GetClosurePtr ...) -> (LoweredGetClosurePtr ...)
+(GetCallerPC ...) -> (LoweredGetCallerPC ...)
+(GetCallerSP ...) -> (LoweredGetCallerSP ...)
+(Addr ...) -> (LoweredAddr ...)
(LocalAddr {sym} base _) -> (LoweredAddr {sym} base)
// Write barrier.
-(WB {fn} destptr srcptr mem) -> (LoweredWB {fn} destptr srcptr mem)
+(WB ...) -> (LoweredWB ...)
// --- Intrinsics ---
-(Sqrt x) -> (F64Sqrt x)
-(Trunc x) -> (F64Trunc x)
-(Ceil x) -> (F64Ceil x)
-(Floor x) -> (F64Floor x)
-(RoundToEven x) -> (F64Nearest x)
-(Abs x) -> (F64Abs x)
-(Copysign x y) -> (F64Copysign x y)
-
-(Ctz64 x) -> (I64Ctz x)
+(Sqrt ...) -> (F64Sqrt ...)
+(Trunc ...) -> (F64Trunc ...)
+(Ceil ...) -> (F64Ceil ...)
+(Floor ...) -> (F64Floor ...)
+(RoundToEven ...) -> (F64Nearest ...)
+(Abs ...) -> (F64Abs ...)
+(Copysign ...) -> (F64Copysign ...)
+
+(Ctz64 ...) -> (I64Ctz ...)
(Ctz32 x) -> (I64Ctz (I64Or x (I64Const [0x100000000])))
(Ctz16 x) -> (I64Ctz (I64Or x (I64Const [0x10000])))
(Ctz8 x) -> (I64Ctz (I64Or x (I64Const [0x100])))
-(Ctz(64|32|16|8)NonZero x) -> (I64Ctz x)
+(Ctz(64|32|16|8)NonZero ...) -> (I64Ctz ...)
(BitLen64 x) -> (I64Sub (I64Const [64]) (I64Clz x))
-(PopCount64 x) -> (I64Popcnt x)
+(PopCount64 ...) -> (I64Popcnt ...)
(PopCount32 x) -> (I64Popcnt (ZeroExt32to64 x))
(PopCount16 x) -> (I64Popcnt (ZeroExt16to64 x))
(PopCount8 x) -> (I64Popcnt (ZeroExt8to64 x))
-(CondSelect <t> x y cond) -> (Select <t> x y cond)
+(CondSelect ...) -> (Select ...)
// --- Optimizations ---
(I64Add (I64Const [x]) (I64Const [y])) -> (I64Const [x + y])
func rewriteValueWasm(v *Value) bool {
switch v.Op {
case OpAbs:
- return rewriteValueWasm_OpAbs(v)
+ v.Op = OpWasmF64Abs
+ return true
case OpAdd16:
- return rewriteValueWasm_OpAdd16(v)
+ v.Op = OpWasmI64Add
+ return true
case OpAdd32:
- return rewriteValueWasm_OpAdd32(v)
+ v.Op = OpWasmI64Add
+ return true
case OpAdd32F:
- return rewriteValueWasm_OpAdd32F(v)
+ v.Op = OpWasmF32Add
+ return true
case OpAdd64:
- return rewriteValueWasm_OpAdd64(v)
+ v.Op = OpWasmI64Add
+ return true
case OpAdd64F:
- return rewriteValueWasm_OpAdd64F(v)
+ v.Op = OpWasmF64Add
+ return true
case OpAdd8:
- return rewriteValueWasm_OpAdd8(v)
+ v.Op = OpWasmI64Add
+ return true
case OpAddPtr:
- return rewriteValueWasm_OpAddPtr(v)
+ v.Op = OpWasmI64Add
+ return true
case OpAddr:
- return rewriteValueWasm_OpAddr(v)
+ v.Op = OpWasmLoweredAddr
+ return true
case OpAnd16:
- return rewriteValueWasm_OpAnd16(v)
+ v.Op = OpWasmI64And
+ return true
case OpAnd32:
- return rewriteValueWasm_OpAnd32(v)
+ v.Op = OpWasmI64And
+ return true
case OpAnd64:
- return rewriteValueWasm_OpAnd64(v)
+ v.Op = OpWasmI64And
+ return true
case OpAnd8:
- return rewriteValueWasm_OpAnd8(v)
+ v.Op = OpWasmI64And
+ return true
case OpAndB:
- return rewriteValueWasm_OpAndB(v)
+ v.Op = OpWasmI64And
+ return true
case OpBitLen64:
return rewriteValueWasm_OpBitLen64(v)
case OpCeil:
- return rewriteValueWasm_OpCeil(v)
+ v.Op = OpWasmF64Ceil
+ return true
case OpClosureCall:
- return rewriteValueWasm_OpClosureCall(v)
+ v.Op = OpWasmLoweredClosureCall
+ return true
case OpCom16:
return rewriteValueWasm_OpCom16(v)
case OpCom32:
case OpCom8:
return rewriteValueWasm_OpCom8(v)
case OpCondSelect:
- return rewriteValueWasm_OpCondSelect(v)
+ v.Op = OpWasmSelect
+ return true
case OpConst16:
- return rewriteValueWasm_OpConst16(v)
+ v.Op = OpWasmI64Const
+ return true
case OpConst32:
- return rewriteValueWasm_OpConst32(v)
+ v.Op = OpWasmI64Const
+ return true
case OpConst32F:
- return rewriteValueWasm_OpConst32F(v)
+ v.Op = OpWasmF32Const
+ return true
case OpConst64:
- return rewriteValueWasm_OpConst64(v)
+ v.Op = OpWasmI64Const
+ return true
case OpConst64F:
- return rewriteValueWasm_OpConst64F(v)
+ v.Op = OpWasmF64Const
+ return true
case OpConst8:
- return rewriteValueWasm_OpConst8(v)
+ v.Op = OpWasmI64Const
+ return true
case OpConstBool:
- return rewriteValueWasm_OpConstBool(v)
+ v.Op = OpWasmI64Const
+ return true
case OpConstNil:
return rewriteValueWasm_OpConstNil(v)
case OpConvert:
- return rewriteValueWasm_OpConvert(v)
+ v.Op = OpWasmLoweredConvert
+ return true
case OpCopysign:
- return rewriteValueWasm_OpCopysign(v)
+ v.Op = OpWasmF64Copysign
+ return true
case OpCtz16:
return rewriteValueWasm_OpCtz16(v)
case OpCtz16NonZero:
- return rewriteValueWasm_OpCtz16NonZero(v)
+ v.Op = OpWasmI64Ctz
+ return true
case OpCtz32:
return rewriteValueWasm_OpCtz32(v)
case OpCtz32NonZero:
- return rewriteValueWasm_OpCtz32NonZero(v)
+ v.Op = OpWasmI64Ctz
+ return true
case OpCtz64:
- return rewriteValueWasm_OpCtz64(v)
+ v.Op = OpWasmI64Ctz
+ return true
case OpCtz64NonZero:
- return rewriteValueWasm_OpCtz64NonZero(v)
+ v.Op = OpWasmI64Ctz
+ return true
case OpCtz8:
return rewriteValueWasm_OpCtz8(v)
case OpCtz8NonZero:
- return rewriteValueWasm_OpCtz8NonZero(v)
+ v.Op = OpWasmI64Ctz
+ return true
case OpCvt32Fto32:
- return rewriteValueWasm_OpCvt32Fto32(v)
+ v.Op = OpWasmI64TruncSatF32S
+ return true
case OpCvt32Fto32U:
- return rewriteValueWasm_OpCvt32Fto32U(v)
+ v.Op = OpWasmI64TruncSatF32U
+ return true
case OpCvt32Fto64:
- return rewriteValueWasm_OpCvt32Fto64(v)
+ v.Op = OpWasmI64TruncSatF32S
+ return true
case OpCvt32Fto64F:
- return rewriteValueWasm_OpCvt32Fto64F(v)
+ v.Op = OpWasmF64PromoteF32
+ return true
case OpCvt32Fto64U:
- return rewriteValueWasm_OpCvt32Fto64U(v)
+ v.Op = OpWasmI64TruncSatF32U
+ return true
case OpCvt32Uto32F:
return rewriteValueWasm_OpCvt32Uto32F(v)
case OpCvt32Uto64F:
case OpCvt32to64F:
return rewriteValueWasm_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValueWasm_OpCvt64Fto32(v)
+ v.Op = OpWasmI64TruncSatF64S
+ return true
case OpCvt64Fto32F:
- return rewriteValueWasm_OpCvt64Fto32F(v)
+ v.Op = OpWasmF32DemoteF64
+ return true
case OpCvt64Fto32U:
- return rewriteValueWasm_OpCvt64Fto32U(v)
+ v.Op = OpWasmI64TruncSatF64U
+ return true
case OpCvt64Fto64:
- return rewriteValueWasm_OpCvt64Fto64(v)
+ v.Op = OpWasmI64TruncSatF64S
+ return true
case OpCvt64Fto64U:
- return rewriteValueWasm_OpCvt64Fto64U(v)
+ v.Op = OpWasmI64TruncSatF64U
+ return true
case OpCvt64Uto32F:
- return rewriteValueWasm_OpCvt64Uto32F(v)
+ v.Op = OpWasmF32ConvertI64U
+ return true
case OpCvt64Uto64F:
- return rewriteValueWasm_OpCvt64Uto64F(v)
+ v.Op = OpWasmF64ConvertI64U
+ return true
case OpCvt64to32F:
- return rewriteValueWasm_OpCvt64to32F(v)
+ v.Op = OpWasmF32ConvertI64S
+ return true
case OpCvt64to64F:
- return rewriteValueWasm_OpCvt64to64F(v)
+ v.Op = OpWasmF64ConvertI64S
+ return true
case OpDiv16:
return rewriteValueWasm_OpDiv16(v)
case OpDiv16u:
case OpDiv32:
return rewriteValueWasm_OpDiv32(v)
case OpDiv32F:
- return rewriteValueWasm_OpDiv32F(v)
+ v.Op = OpWasmF32Div
+ return true
case OpDiv32u:
return rewriteValueWasm_OpDiv32u(v)
case OpDiv64:
return rewriteValueWasm_OpDiv64(v)
case OpDiv64F:
- return rewriteValueWasm_OpDiv64F(v)
+ v.Op = OpWasmF64Div
+ return true
case OpDiv64u:
- return rewriteValueWasm_OpDiv64u(v)
+ v.Op = OpWasmI64DivU
+ return true
case OpDiv8:
return rewriteValueWasm_OpDiv8(v)
case OpDiv8u:
case OpEq32:
return rewriteValueWasm_OpEq32(v)
case OpEq32F:
- return rewriteValueWasm_OpEq32F(v)
+ v.Op = OpWasmF32Eq
+ return true
case OpEq64:
- return rewriteValueWasm_OpEq64(v)
+ v.Op = OpWasmI64Eq
+ return true
case OpEq64F:
- return rewriteValueWasm_OpEq64F(v)
+ v.Op = OpWasmF64Eq
+ return true
case OpEq8:
return rewriteValueWasm_OpEq8(v)
case OpEqB:
- return rewriteValueWasm_OpEqB(v)
+ v.Op = OpWasmI64Eq
+ return true
case OpEqPtr:
- return rewriteValueWasm_OpEqPtr(v)
+ v.Op = OpWasmI64Eq
+ return true
case OpFloor:
- return rewriteValueWasm_OpFloor(v)
+ v.Op = OpWasmF64Floor
+ return true
case OpGeq16:
return rewriteValueWasm_OpGeq16(v)
case OpGeq16U:
case OpGeq32:
return rewriteValueWasm_OpGeq32(v)
case OpGeq32F:
- return rewriteValueWasm_OpGeq32F(v)
+ v.Op = OpWasmF32Ge
+ return true
case OpGeq32U:
return rewriteValueWasm_OpGeq32U(v)
case OpGeq64:
- return rewriteValueWasm_OpGeq64(v)
+ v.Op = OpWasmI64GeS
+ return true
case OpGeq64F:
- return rewriteValueWasm_OpGeq64F(v)
+ v.Op = OpWasmF64Ge
+ return true
case OpGeq64U:
- return rewriteValueWasm_OpGeq64U(v)
+ v.Op = OpWasmI64GeU
+ return true
case OpGeq8:
return rewriteValueWasm_OpGeq8(v)
case OpGeq8U:
return rewriteValueWasm_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValueWasm_OpGetCallerPC(v)
+ v.Op = OpWasmLoweredGetCallerPC
+ return true
case OpGetCallerSP:
- return rewriteValueWasm_OpGetCallerSP(v)
+ v.Op = OpWasmLoweredGetCallerSP
+ return true
case OpGetClosurePtr:
- return rewriteValueWasm_OpGetClosurePtr(v)
+ v.Op = OpWasmLoweredGetClosurePtr
+ return true
case OpGreater16:
return rewriteValueWasm_OpGreater16(v)
case OpGreater16U:
case OpGreater32:
return rewriteValueWasm_OpGreater32(v)
case OpGreater32F:
- return rewriteValueWasm_OpGreater32F(v)
+ v.Op = OpWasmF32Gt
+ return true
case OpGreater32U:
return rewriteValueWasm_OpGreater32U(v)
case OpGreater64:
- return rewriteValueWasm_OpGreater64(v)
+ v.Op = OpWasmI64GtS
+ return true
case OpGreater64F:
- return rewriteValueWasm_OpGreater64F(v)
+ v.Op = OpWasmF64Gt
+ return true
case OpGreater64U:
- return rewriteValueWasm_OpGreater64U(v)
+ v.Op = OpWasmI64GtU
+ return true
case OpGreater8:
return rewriteValueWasm_OpGreater8(v)
case OpGreater8U:
return rewriteValueWasm_OpGreater8U(v)
case OpInterCall:
- return rewriteValueWasm_OpInterCall(v)
+ v.Op = OpWasmLoweredInterCall
+ return true
case OpIsInBounds:
- return rewriteValueWasm_OpIsInBounds(v)
+ v.Op = OpWasmI64LtU
+ return true
case OpIsNonNil:
return rewriteValueWasm_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValueWasm_OpIsSliceInBounds(v)
+ v.Op = OpWasmI64LeU
+ return true
case OpLeq16:
return rewriteValueWasm_OpLeq16(v)
case OpLeq16U:
case OpLeq32:
return rewriteValueWasm_OpLeq32(v)
case OpLeq32F:
- return rewriteValueWasm_OpLeq32F(v)
+ v.Op = OpWasmF32Le
+ return true
case OpLeq32U:
return rewriteValueWasm_OpLeq32U(v)
case OpLeq64:
- return rewriteValueWasm_OpLeq64(v)
+ v.Op = OpWasmI64LeS
+ return true
case OpLeq64F:
- return rewriteValueWasm_OpLeq64F(v)
+ v.Op = OpWasmF64Le
+ return true
case OpLeq64U:
- return rewriteValueWasm_OpLeq64U(v)
+ v.Op = OpWasmI64LeU
+ return true
case OpLeq8:
return rewriteValueWasm_OpLeq8(v)
case OpLeq8U:
case OpLess32:
return rewriteValueWasm_OpLess32(v)
case OpLess32F:
- return rewriteValueWasm_OpLess32F(v)
+ v.Op = OpWasmF32Lt
+ return true
case OpLess32U:
return rewriteValueWasm_OpLess32U(v)
case OpLess64:
- return rewriteValueWasm_OpLess64(v)
+ v.Op = OpWasmI64LtS
+ return true
case OpLess64F:
- return rewriteValueWasm_OpLess64F(v)
+ v.Op = OpWasmF64Lt
+ return true
case OpLess64U:
- return rewriteValueWasm_OpLess64U(v)
+ v.Op = OpWasmI64LtU
+ return true
case OpLess8:
return rewriteValueWasm_OpLess8(v)
case OpLess8U:
case OpLsh16x32:
return rewriteValueWasm_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValueWasm_OpLsh16x64(v)
+ v.Op = OpLsh64x64
+ return true
case OpLsh16x8:
return rewriteValueWasm_OpLsh16x8(v)
case OpLsh32x16:
case OpLsh32x32:
return rewriteValueWasm_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValueWasm_OpLsh32x64(v)
+ v.Op = OpLsh64x64
+ return true
case OpLsh32x8:
return rewriteValueWasm_OpLsh32x8(v)
case OpLsh64x16:
case OpLsh8x32:
return rewriteValueWasm_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValueWasm_OpLsh8x64(v)
+ v.Op = OpLsh64x64
+ return true
case OpLsh8x8:
return rewriteValueWasm_OpLsh8x8(v)
case OpMod16:
case OpMod64:
return rewriteValueWasm_OpMod64(v)
case OpMod64u:
- return rewriteValueWasm_OpMod64u(v)
+ v.Op = OpWasmI64RemU
+ return true
case OpMod8:
return rewriteValueWasm_OpMod8(v)
case OpMod8u:
case OpMove:
return rewriteValueWasm_OpMove(v)
case OpMul16:
- return rewriteValueWasm_OpMul16(v)
+ v.Op = OpWasmI64Mul
+ return true
case OpMul32:
- return rewriteValueWasm_OpMul32(v)
+ v.Op = OpWasmI64Mul
+ return true
case OpMul32F:
- return rewriteValueWasm_OpMul32F(v)
+ v.Op = OpWasmF32Mul
+ return true
case OpMul64:
- return rewriteValueWasm_OpMul64(v)
+ v.Op = OpWasmI64Mul
+ return true
case OpMul64F:
- return rewriteValueWasm_OpMul64F(v)
+ v.Op = OpWasmF64Mul
+ return true
case OpMul8:
- return rewriteValueWasm_OpMul8(v)
+ v.Op = OpWasmI64Mul
+ return true
case OpNeg16:
return rewriteValueWasm_OpNeg16(v)
case OpNeg32:
return rewriteValueWasm_OpNeg32(v)
case OpNeg32F:
- return rewriteValueWasm_OpNeg32F(v)
+ v.Op = OpWasmF32Neg
+ return true
case OpNeg64:
return rewriteValueWasm_OpNeg64(v)
case OpNeg64F:
- return rewriteValueWasm_OpNeg64F(v)
+ v.Op = OpWasmF64Neg
+ return true
case OpNeg8:
return rewriteValueWasm_OpNeg8(v)
case OpNeq16:
case OpNeq32:
return rewriteValueWasm_OpNeq32(v)
case OpNeq32F:
- return rewriteValueWasm_OpNeq32F(v)
+ v.Op = OpWasmF32Ne
+ return true
case OpNeq64:
- return rewriteValueWasm_OpNeq64(v)
+ v.Op = OpWasmI64Ne
+ return true
case OpNeq64F:
- return rewriteValueWasm_OpNeq64F(v)
+ v.Op = OpWasmF64Ne
+ return true
case OpNeq8:
return rewriteValueWasm_OpNeq8(v)
case OpNeqB:
- return rewriteValueWasm_OpNeqB(v)
+ v.Op = OpWasmI64Ne
+ return true
case OpNeqPtr:
- return rewriteValueWasm_OpNeqPtr(v)
+ v.Op = OpWasmI64Ne
+ return true
case OpNilCheck:
- return rewriteValueWasm_OpNilCheck(v)
+ v.Op = OpWasmLoweredNilCheck
+ return true
case OpNot:
- return rewriteValueWasm_OpNot(v)
+ v.Op = OpWasmI64Eqz
+ return true
case OpOffPtr:
- return rewriteValueWasm_OpOffPtr(v)
+ v.Op = OpWasmI64AddConst
+ return true
case OpOr16:
- return rewriteValueWasm_OpOr16(v)
+ v.Op = OpWasmI64Or
+ return true
case OpOr32:
- return rewriteValueWasm_OpOr32(v)
+ v.Op = OpWasmI64Or
+ return true
case OpOr64:
- return rewriteValueWasm_OpOr64(v)
+ v.Op = OpWasmI64Or
+ return true
case OpOr8:
- return rewriteValueWasm_OpOr8(v)
+ v.Op = OpWasmI64Or
+ return true
case OpOrB:
- return rewriteValueWasm_OpOrB(v)
+ v.Op = OpWasmI64Or
+ return true
case OpPopCount16:
return rewriteValueWasm_OpPopCount16(v)
case OpPopCount32:
return rewriteValueWasm_OpPopCount32(v)
case OpPopCount64:
- return rewriteValueWasm_OpPopCount64(v)
+ v.Op = OpWasmI64Popcnt
+ return true
case OpPopCount8:
return rewriteValueWasm_OpPopCount8(v)
case OpRotateLeft16:
return rewriteValueWasm_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValueWasm_OpRotateLeft32(v)
+ v.Op = OpWasmI32Rotl
+ return true
case OpRotateLeft64:
- return rewriteValueWasm_OpRotateLeft64(v)
+ v.Op = OpWasmI64Rotl
+ return true
case OpRotateLeft8:
return rewriteValueWasm_OpRotateLeft8(v)
case OpRound32F:
- return rewriteValueWasm_OpRound32F(v)
+ v.Op = OpCopy
+ return true
case OpRound64F:
- return rewriteValueWasm_OpRound64F(v)
+ v.Op = OpCopy
+ return true
case OpRoundToEven:
- return rewriteValueWasm_OpRoundToEven(v)
+ v.Op = OpWasmF64Nearest
+ return true
case OpRsh16Ux16:
return rewriteValueWasm_OpRsh16Ux16(v)
case OpRsh16Ux32:
case OpSlicemask:
return rewriteValueWasm_OpSlicemask(v)
case OpSqrt:
- return rewriteValueWasm_OpSqrt(v)
+ v.Op = OpWasmF64Sqrt
+ return true
case OpStaticCall:
- return rewriteValueWasm_OpStaticCall(v)
+ v.Op = OpWasmLoweredStaticCall
+ return true
case OpStore:
return rewriteValueWasm_OpStore(v)
case OpSub16:
- return rewriteValueWasm_OpSub16(v)
+ v.Op = OpWasmI64Sub
+ return true
case OpSub32:
- return rewriteValueWasm_OpSub32(v)
+ v.Op = OpWasmI64Sub
+ return true
case OpSub32F:
- return rewriteValueWasm_OpSub32F(v)
+ v.Op = OpWasmF32Sub
+ return true
case OpSub64:
- return rewriteValueWasm_OpSub64(v)
+ v.Op = OpWasmI64Sub
+ return true
case OpSub64F:
- return rewriteValueWasm_OpSub64F(v)
+ v.Op = OpWasmF64Sub
+ return true
case OpSub8:
- return rewriteValueWasm_OpSub8(v)
+ v.Op = OpWasmI64Sub
+ return true
case OpSubPtr:
- return rewriteValueWasm_OpSubPtr(v)
+ v.Op = OpWasmI64Sub
+ return true
case OpTrunc:
- return rewriteValueWasm_OpTrunc(v)
+ v.Op = OpWasmF64Trunc
+ return true
case OpTrunc16to8:
- return rewriteValueWasm_OpTrunc16to8(v)
+ v.Op = OpCopy
+ return true
case OpTrunc32to16:
- return rewriteValueWasm_OpTrunc32to16(v)
+ v.Op = OpCopy
+ return true
case OpTrunc32to8:
- return rewriteValueWasm_OpTrunc32to8(v)
+ v.Op = OpCopy
+ return true
case OpTrunc64to16:
- return rewriteValueWasm_OpTrunc64to16(v)
+ v.Op = OpCopy
+ return true
case OpTrunc64to32:
- return rewriteValueWasm_OpTrunc64to32(v)
+ v.Op = OpCopy
+ return true
case OpTrunc64to8:
- return rewriteValueWasm_OpTrunc64to8(v)
+ v.Op = OpCopy
+ return true
case OpWB:
- return rewriteValueWasm_OpWB(v)
+ v.Op = OpWasmLoweredWB
+ return true
case OpWasmF64Add:
return rewriteValueWasm_OpWasmF64Add(v)
case OpWasmF64Mul:
case OpWasmI64Xor:
return rewriteValueWasm_OpWasmI64Xor(v)
case OpXor16:
- return rewriteValueWasm_OpXor16(v)
+ v.Op = OpWasmI64Xor
+ return true
case OpXor32:
- return rewriteValueWasm_OpXor32(v)
+ v.Op = OpWasmI64Xor
+ return true
case OpXor64:
- return rewriteValueWasm_OpXor64(v)
+ v.Op = OpWasmI64Xor
+ return true
case OpXor8:
- return rewriteValueWasm_OpXor8(v)
+ v.Op = OpWasmI64Xor
+ return true
case OpZero:
return rewriteValueWasm_OpZero(v)
case OpZeroExt16to32:
}
return false
}
-func rewriteValueWasm_OpAbs(v *Value) bool {
+func rewriteValueWasm_OpBitLen64(v *Value) bool {
v_0 := v.Args[0]
- // match: (Abs x)
- // result: (F64Abs x)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (BitLen64 x)
+ // result: (I64Sub (I64Const [64]) (I64Clz x))
for {
x := v_0
- v.reset(OpWasmF64Abs)
- v.AddArg(x)
+ v.reset(OpWasmI64Sub)
+ v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v0.AuxInt = 64
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Pos, OpWasmI64Clz, typ.Int64)
+ v1.AddArg(x)
+ v.AddArg(v1)
return true
}
}
-func rewriteValueWasm_OpAdd16(v *Value) bool {
- v_1 := v.Args[1]
+func rewriteValueWasm_OpCom16(v *Value) bool {
v_0 := v.Args[0]
- // match: (Add16 x y)
- // result: (I64Add x y)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Com16 x)
+ // result: (I64Xor x (I64Const [-1]))
for {
x := v_0
- y := v_1
- v.reset(OpWasmI64Add)
+ v.reset(OpWasmI64Xor)
v.AddArg(x)
- v.AddArg(y)
+ v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v0.AuxInt = -1
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpAdd32(v *Value) bool {
- v_1 := v.Args[1]
+func rewriteValueWasm_OpCom32(v *Value) bool {
v_0 := v.Args[0]
- // match: (Add32 x y)
- // result: (I64Add x y)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Com32 x)
+ // result: (I64Xor x (I64Const [-1]))
for {
x := v_0
- y := v_1
- v.reset(OpWasmI64Add)
+ v.reset(OpWasmI64Xor)
v.AddArg(x)
- v.AddArg(y)
+ v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v0.AuxInt = -1
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpAdd32F(v *Value) bool {
- v_1 := v.Args[1]
+func rewriteValueWasm_OpCom64(v *Value) bool {
v_0 := v.Args[0]
- // match: (Add32F x y)
- // result: (F32Add x y)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Com64 x)
+ // result: (I64Xor x (I64Const [-1]))
for {
x := v_0
- y := v_1
- v.reset(OpWasmF32Add)
+ v.reset(OpWasmI64Xor)
v.AddArg(x)
- v.AddArg(y)
+ v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v0.AuxInt = -1
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpAdd64(v *Value) bool {
- v_1 := v.Args[1]
+func rewriteValueWasm_OpCom8(v *Value) bool {
v_0 := v.Args[0]
- // match: (Add64 x y)
- // result: (I64Add x y)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Com8 x)
+ // result: (I64Xor x (I64Const [-1]))
for {
x := v_0
- y := v_1
- v.reset(OpWasmI64Add)
+ v.reset(OpWasmI64Xor)
v.AddArg(x)
- v.AddArg(y)
+ v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v0.AuxInt = -1
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpAdd64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Add64F x y)
- // result: (F64Add x y)
+func rewriteValueWasm_OpConstNil(v *Value) bool {
+ // match: (ConstNil)
+ // result: (I64Const [0])
for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Add)
- v.AddArg(x)
- v.AddArg(y)
+ v.reset(OpWasmI64Const)
+ v.AuxInt = 0
return true
}
}
-func rewriteValueWasm_OpAdd8(v *Value) bool {
- v_1 := v.Args[1]
+func rewriteValueWasm_OpCtz16(v *Value) bool {
v_0 := v.Args[0]
- // match: (Add8 x y)
- // result: (I64Add x y)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Ctz16 x)
+ // result: (I64Ctz (I64Or x (I64Const [0x10000])))
for {
x := v_0
- y := v_1
- v.reset(OpWasmI64Add)
- v.AddArg(x)
- v.AddArg(y)
+ v.reset(OpWasmI64Ctz)
+ v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
+ v0.AddArg(x)
+ v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v1.AuxInt = 0x10000
+ v0.AddArg(v1)
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpAddPtr(v *Value) bool {
- v_1 := v.Args[1]
+func rewriteValueWasm_OpCtz32(v *Value) bool {
v_0 := v.Args[0]
- // match: (AddPtr x y)
- // result: (I64Add x y)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Ctz32 x)
+ // result: (I64Ctz (I64Or x (I64Const [0x100000000])))
for {
x := v_0
- y := v_1
- v.reset(OpWasmI64Add)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpAddr(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Addr {sym} base)
- // result: (LoweredAddr {sym} base)
- for {
- sym := v.Aux
- base := v_0
- v.reset(OpWasmLoweredAddr)
- v.Aux = sym
- v.AddArg(base)
+ v.reset(OpWasmI64Ctz)
+ v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
+ v0.AddArg(x)
+ v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v1.AuxInt = 0x100000000
+ v0.AddArg(v1)
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpAnd16(v *Value) bool {
- v_1 := v.Args[1]
+func rewriteValueWasm_OpCtz8(v *Value) bool {
v_0 := v.Args[0]
- // match: (And16 x y)
- // result: (I64And x y)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Ctz8 x)
+ // result: (I64Ctz (I64Or x (I64Const [0x100])))
for {
x := v_0
- y := v_1
- v.reset(OpWasmI64And)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpAnd32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (And32 x y)
- // result: (I64And x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64And)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpAnd64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (And64 x y)
- // result: (I64And x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64And)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpAnd8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (And8 x y)
- // result: (I64And x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64And)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpAndB(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AndB x y)
- // result: (I64And x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64And)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpBitLen64(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (BitLen64 x)
- // result: (I64Sub (I64Const [64]) (I64Clz x))
- for {
- x := v_0
- v.reset(OpWasmI64Sub)
- v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v0.AuxInt = 64
- v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpWasmI64Clz, typ.Int64)
- v1.AddArg(x)
- v.AddArg(v1)
- return true
- }
-}
-func rewriteValueWasm_OpCeil(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Ceil x)
- // result: (F64Ceil x)
- for {
- x := v_0
- v.reset(OpWasmF64Ceil)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpClosureCall(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (ClosureCall [argwid] entry closure mem)
- // result: (LoweredClosureCall [argwid] entry closure mem)
- for {
- argwid := v.AuxInt
- entry := v_0
- closure := v_1
- mem := v_2
- v.reset(OpWasmLoweredClosureCall)
- v.AuxInt = argwid
- v.AddArg(entry)
- v.AddArg(closure)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueWasm_OpCom16(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Com16 x)
- // result: (I64Xor x (I64Const [-1]))
- for {
- x := v_0
- v.reset(OpWasmI64Xor)
- v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v0.AuxInt = -1
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCom32(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Com32 x)
- // result: (I64Xor x (I64Const [-1]))
- for {
- x := v_0
- v.reset(OpWasmI64Xor)
- v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v0.AuxInt = -1
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCom64(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Com64 x)
- // result: (I64Xor x (I64Const [-1]))
- for {
- x := v_0
- v.reset(OpWasmI64Xor)
- v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v0.AuxInt = -1
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCom8(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Com8 x)
- // result: (I64Xor x (I64Const [-1]))
- for {
- x := v_0
- v.reset(OpWasmI64Xor)
- v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v0.AuxInt = -1
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCondSelect(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (CondSelect <t> x y cond)
- // result: (Select <t> x y cond)
- for {
- t := v.Type
- x := v_0
- y := v_1
- cond := v_2
- v.reset(OpWasmSelect)
- v.Type = t
- v.AddArg(x)
- v.AddArg(y)
- v.AddArg(cond)
- return true
- }
-}
-func rewriteValueWasm_OpConst16(v *Value) bool {
- // match: (Const16 [val])
- // result: (I64Const [val])
- for {
- val := v.AuxInt
- v.reset(OpWasmI64Const)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueWasm_OpConst32(v *Value) bool {
- // match: (Const32 [val])
- // result: (I64Const [val])
- for {
- val := v.AuxInt
- v.reset(OpWasmI64Const)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueWasm_OpConst32F(v *Value) bool {
- // match: (Const32F [val])
- // result: (F32Const [val])
- for {
- val := v.AuxInt
- v.reset(OpWasmF32Const)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueWasm_OpConst64(v *Value) bool {
- // match: (Const64 [val])
- // result: (I64Const [val])
- for {
- val := v.AuxInt
- v.reset(OpWasmI64Const)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueWasm_OpConst64F(v *Value) bool {
- // match: (Const64F [val])
- // result: (F64Const [val])
- for {
- val := v.AuxInt
- v.reset(OpWasmF64Const)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueWasm_OpConst8(v *Value) bool {
- // match: (Const8 [val])
- // result: (I64Const [val])
- for {
- val := v.AuxInt
- v.reset(OpWasmI64Const)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueWasm_OpConstBool(v *Value) bool {
- // match: (ConstBool [b])
- // result: (I64Const [b])
- for {
- b := v.AuxInt
- v.reset(OpWasmI64Const)
- v.AuxInt = b
- return true
- }
-}
-func rewriteValueWasm_OpConstNil(v *Value) bool {
- // match: (ConstNil)
- // result: (I64Const [0])
- for {
- v.reset(OpWasmI64Const)
- v.AuxInt = 0
- return true
- }
-}
-func rewriteValueWasm_OpConvert(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Convert <t> x mem)
- // result: (LoweredConvert <t> x mem)
- for {
- t := v.Type
- x := v_0
- mem := v_1
- v.reset(OpWasmLoweredConvert)
- v.Type = t
- v.AddArg(x)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueWasm_OpCopysign(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Copysign x y)
- // result: (F64Copysign x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Copysign)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpCtz16(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Ctz16 x)
- // result: (I64Ctz (I64Or x (I64Const [0x10000])))
- for {
- x := v_0
- v.reset(OpWasmI64Ctz)
- v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
- v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v1.AuxInt = 0x10000
- v0.AddArg(v1)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCtz16NonZero(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Ctz16NonZero x)
- // result: (I64Ctz x)
- for {
- x := v_0
- v.reset(OpWasmI64Ctz)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCtz32(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Ctz32 x)
- // result: (I64Ctz (I64Or x (I64Const [0x100000000])))
- for {
- x := v_0
- v.reset(OpWasmI64Ctz)
- v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
- v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v1.AuxInt = 0x100000000
- v0.AddArg(v1)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCtz32NonZero(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Ctz32NonZero x)
- // result: (I64Ctz x)
- for {
- x := v_0
- v.reset(OpWasmI64Ctz)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCtz64(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Ctz64 x)
- // result: (I64Ctz x)
- for {
- x := v_0
- v.reset(OpWasmI64Ctz)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCtz64NonZero(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Ctz64NonZero x)
- // result: (I64Ctz x)
- for {
- x := v_0
- v.reset(OpWasmI64Ctz)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCtz8(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Ctz8 x)
- // result: (I64Ctz (I64Or x (I64Const [0x100])))
- for {
- x := v_0
- v.reset(OpWasmI64Ctz)
- v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
- v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v1.AuxInt = 0x100
- v0.AddArg(v1)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCtz8NonZero(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Ctz8NonZero x)
- // result: (I64Ctz x)
- for {
- x := v_0
- v.reset(OpWasmI64Ctz)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt32Fto32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt32Fto32 x)
- // result: (I64TruncSatF32S x)
- for {
- x := v_0
- v.reset(OpWasmI64TruncSatF32S)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt32Fto32U(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt32Fto32U x)
- // result: (I64TruncSatF32U x)
- for {
- x := v_0
- v.reset(OpWasmI64TruncSatF32U)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt32Fto64(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt32Fto64 x)
- // result: (I64TruncSatF32S x)
- for {
- x := v_0
- v.reset(OpWasmI64TruncSatF32S)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt32Fto64F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt32Fto64F x)
- // result: (F64PromoteF32 x)
- for {
- x := v_0
- v.reset(OpWasmF64PromoteF32)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt32Fto64U(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt32Fto64U x)
- // result: (I64TruncSatF32U x)
- for {
- x := v_0
- v.reset(OpWasmI64TruncSatF32U)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt32Uto32F(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Cvt32Uto32F x)
- // result: (F32ConvertI64U (ZeroExt32to64 x))
- for {
- x := v_0
- v.reset(OpWasmF32ConvertI64U)
- v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
- v0.AddArg(x)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCvt32Uto64F(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Cvt32Uto64F x)
- // result: (F64ConvertI64U (ZeroExt32to64 x))
- for {
- x := v_0
- v.reset(OpWasmF64ConvertI64U)
- v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
- v0.AddArg(x)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCvt32to32F(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Cvt32to32F x)
- // result: (F32ConvertI64S (SignExt32to64 x))
- for {
- x := v_0
- v.reset(OpWasmF32ConvertI64S)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
- v0.AddArg(x)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCvt32to64F(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
- // match: (Cvt32to64F x)
- // result: (F64ConvertI64S (SignExt32to64 x))
- for {
- x := v_0
- v.reset(OpWasmF64ConvertI64S)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
- v0.AddArg(x)
- v.AddArg(v0)
- return true
- }
-}
-func rewriteValueWasm_OpCvt64Fto32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt64Fto32 x)
- // result: (I64TruncSatF64S x)
- for {
- x := v_0
- v.reset(OpWasmI64TruncSatF64S)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt64Fto32F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt64Fto32F x)
- // result: (F32DemoteF64 x)
- for {
- x := v_0
- v.reset(OpWasmF32DemoteF64)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt64Fto32U(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt64Fto32U x)
- // result: (I64TruncSatF64U x)
- for {
- x := v_0
- v.reset(OpWasmI64TruncSatF64U)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt64Fto64(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt64Fto64 x)
- // result: (I64TruncSatF64S x)
- for {
- x := v_0
- v.reset(OpWasmI64TruncSatF64S)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpCvt64Fto64U(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt64Fto64U x)
- // result: (I64TruncSatF64U x)
- for {
- x := v_0
- v.reset(OpWasmI64TruncSatF64U)
- v.AddArg(x)
+ v.reset(OpWasmI64Ctz)
+ v0 := b.NewValue0(v.Pos, OpWasmI64Or, typ.Int64)
+ v0.AddArg(x)
+ v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v1.AuxInt = 0x100
+ v0.AddArg(v1)
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpCvt64Uto32F(v *Value) bool {
+func rewriteValueWasm_OpCvt32Uto32F(v *Value) bool {
v_0 := v.Args[0]
- // match: (Cvt64Uto32F x)
- // result: (F32ConvertI64U x)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Cvt32Uto32F x)
+ // result: (F32ConvertI64U (ZeroExt32to64 x))
for {
x := v_0
v.reset(OpWasmF32ConvertI64U)
- v.AddArg(x)
+ v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
+ v0.AddArg(x)
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpCvt64Uto64F(v *Value) bool {
+func rewriteValueWasm_OpCvt32Uto64F(v *Value) bool {
v_0 := v.Args[0]
- // match: (Cvt64Uto64F x)
- // result: (F64ConvertI64U x)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Cvt32Uto64F x)
+ // result: (F64ConvertI64U (ZeroExt32to64 x))
for {
x := v_0
v.reset(OpWasmF64ConvertI64U)
- v.AddArg(x)
+ v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
+ v0.AddArg(x)
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpCvt64to32F(v *Value) bool {
+func rewriteValueWasm_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
- // match: (Cvt64to32F x)
- // result: (F32ConvertI64S x)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Cvt32to32F x)
+ // result: (F32ConvertI64S (SignExt32to64 x))
for {
x := v_0
v.reset(OpWasmF32ConvertI64S)
- v.AddArg(x)
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
+ v0.AddArg(x)
+ v.AddArg(v0)
return true
}
}
-func rewriteValueWasm_OpCvt64to64F(v *Value) bool {
+func rewriteValueWasm_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
- // match: (Cvt64to64F x)
- // result: (F64ConvertI64S x)
+ b := v.Block
+ typ := &b.Func.Config.Types
+ // match: (Cvt32to64F x)
+ // result: (F64ConvertI64S (SignExt32to64 x))
for {
x := v_0
v.reset(OpWasmF64ConvertI64S)
- v.AddArg(x)
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
+ v0.AddArg(x)
+ v.AddArg(v0)
return true
}
}
return true
}
}
-func rewriteValueWasm_OpDiv32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Div32F x y)
- // result: (F32Div x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF32Div)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
func rewriteValueWasm_OpDiv64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
- // match: (Div64 x y)
+ // match: (Div64 [a] x y)
// result: (I64DivS x y)
for {
x := v_0
return true
}
}
-func rewriteValueWasm_OpDiv64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Div64F x y)
- // result: (F64Div x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Div)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpDiv64u(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Div64u x y)
- // result: (I64DivU x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64DivU)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpEq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Eq32F x y)
- // result: (F32Eq x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF32Eq)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpEq64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Eq64 x y)
- // result: (I64Eq x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Eq)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpEq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Eq64F x y)
- // result: (F64Eq x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Eq)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpEqB(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (EqB x y)
- // result: (I64Eq x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Eq)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpEqPtr(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (EqPtr x y)
- // result: (I64Eq x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Eq)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpFloor(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Floor x)
- // result: (F64Floor x)
- for {
- x := v_0
- v.reset(OpWasmF64Floor)
- v.AddArg(x)
- return true
- }
-}
func rewriteValueWasm_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpGeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Geq32F x y)
- // result: (F32Ge x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF32Ge)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpGeq64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Geq64 x y)
- // result: (I64GeS x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64GeS)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpGeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Geq64F x y)
- // result: (F64Ge x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Ge)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpGeq64U(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Geq64U x y)
- // result: (I64GeU x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64GeU)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpGetCallerPC(v *Value) bool {
- // match: (GetCallerPC)
- // result: (LoweredGetCallerPC)
- for {
- v.reset(OpWasmLoweredGetCallerPC)
- return true
- }
-}
-func rewriteValueWasm_OpGetCallerSP(v *Value) bool {
- // match: (GetCallerSP)
- // result: (LoweredGetCallerSP)
- for {
- v.reset(OpWasmLoweredGetCallerSP)
- return true
- }
-}
-func rewriteValueWasm_OpGetClosurePtr(v *Value) bool {
- // match: (GetClosurePtr)
- // result: (LoweredGetClosurePtr)
- for {
- v.reset(OpWasmLoweredGetClosurePtr)
- return true
- }
-}
func rewriteValueWasm_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpGreater32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater32F x y)
- // result: (F32Gt x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF32Gt)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpGreater64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater64 x y)
- // result: (I64GtS x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64GtS)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpGreater64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater64F x y)
- // result: (F64Gt x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Gt)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpGreater64U(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater64U x y)
- // result: (I64GtU x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64GtU)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
for {
x := v_0
y := v_1
- v.reset(OpWasmI64GtU)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
- v0.AddArg(x)
- v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
- v1.AddArg(y)
- v.AddArg(v1)
- return true
- }
-}
-func rewriteValueWasm_OpInterCall(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (InterCall [argwid] entry mem)
- // result: (LoweredInterCall [argwid] entry mem)
- for {
- argwid := v.AuxInt
- entry := v_0
- mem := v_1
- v.reset(OpWasmLoweredInterCall)
- v.AuxInt = argwid
- v.AddArg(entry)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueWasm_OpIsInBounds(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (IsInBounds idx len)
- // result: (I64LtU idx len)
- for {
- idx := v_0
- len := v_1
- v.reset(OpWasmI64LtU)
- v.AddArg(idx)
- v.AddArg(len)
+ v.reset(OpWasmI64GtU)
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
+ v0.AddArg(x)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
+ v1.AddArg(y)
+ v.AddArg(v1)
return true
}
}
return true
}
}
-func rewriteValueWasm_OpIsSliceInBounds(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (IsSliceInBounds idx len)
- // result: (I64LeU idx len)
- for {
- idx := v_0
- len := v_1
- v.reset(OpWasmI64LeU)
- v.AddArg(idx)
- v.AddArg(len)
- return true
- }
-}
func rewriteValueWasm_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpLeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Leq32F x y)
- // result: (F32Le x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF32Le)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpLeq64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Leq64 x y)
- // result: (I64LeS x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64LeS)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpLeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Leq64F x y)
- // result: (F64Le x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Le)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpLeq64U(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Leq64U x y)
- // result: (I64LeU x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64LeU)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpLess32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Less32F x y)
- // result: (F32Lt x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF32Lt)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpLess64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Less64 x y)
- // result: (I64LtS x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64LtS)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpLess64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Less64F x y)
- // result: (F64Lt x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Lt)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpLess64U(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Less64U x y)
- // result: (I64LtU x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64LtU)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpLsh16x64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Lsh16x64 [c] x y)
- // result: (Lsh64x64 [c] x y)
- for {
- c := v.AuxInt
- x := v_0
- y := v_1
- v.reset(OpLsh64x64)
- v.AuxInt = c
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpLsh32x64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Lsh32x64 [c] x y)
- // result: (Lsh64x64 [c] x y)
- for {
- c := v.AuxInt
- x := v_0
- y := v_1
- v.reset(OpLsh64x64)
- v.AuxInt = c
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpLsh8x64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Lsh8x64 [c] x y)
- // result: (Lsh64x64 [c] x y)
- for {
- c := v.AuxInt
- x := v_0
- y := v_1
- v.reset(OpLsh64x64)
- v.AuxInt = c
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
func rewriteValueWasm_OpMod64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
- // match: (Mod64 x y)
+ // match: (Mod64 [a] x y)
// result: (I64RemS x y)
for {
x := v_0
return true
}
}
-func rewriteValueWasm_OpMod64u(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mod64u x y)
- // result: (I64RemU x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64RemU)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Move [s] dst src mem)
// cond: s > 16 && s%16 != 0 && s%16 > 8
// result: (Move [s-s%16] (OffPtr <dst.Type> dst [s%16]) (OffPtr <src.Type> src [s%16]) (I64Store [8] dst (I64Load [8] src mem) (I64Store dst (I64Load src mem) mem)))
- for {
- s := v.AuxInt
- dst := v_0
- src := v_1
- mem := v_2
- if !(s > 16 && s%16 != 0 && s%16 > 8) {
- break
- }
- v.reset(OpMove)
- v.AuxInt = s - s%16
- v0 := b.NewValue0(v.Pos, OpOffPtr, dst.Type)
- v0.AuxInt = s % 16
- v0.AddArg(dst)
- v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpOffPtr, src.Type)
- v1.AuxInt = s % 16
- v1.AddArg(src)
- v.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
- v2.AuxInt = 8
- v2.AddArg(dst)
- v3 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
- v3.AuxInt = 8
- v3.AddArg(src)
- v3.AddArg(mem)
- v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
- v4.AddArg(dst)
- v5 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
- v5.AddArg(src)
- v5.AddArg(mem)
- v4.AddArg(v5)
- v4.AddArg(mem)
- v2.AddArg(v4)
- v.AddArg(v2)
- return true
- }
- // match: (Move [s] dst src mem)
- // cond: s%8 == 0
- // result: (LoweredMove [s/8] dst src mem)
- for {
- s := v.AuxInt
- dst := v_0
- src := v_1
- mem := v_2
- if !(s%8 == 0) {
- break
- }
- v.reset(OpWasmLoweredMove)
- v.AuxInt = s / 8
- v.AddArg(dst)
- v.AddArg(src)
- v.AddArg(mem)
- return true
- }
- return false
-}
-func rewriteValueWasm_OpMul16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul16 x y)
- // result: (I64Mul x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Mul)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpMul32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul32 x y)
- // result: (I64Mul x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Mul)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpMul32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul32F x y)
- // result: (F32Mul x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF32Mul)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpMul64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul64 x y)
- // result: (I64Mul x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Mul)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpMul64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul64F x y)
- // result: (F64Mul x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Mul)
- v.AddArg(x)
- v.AddArg(y)
+ for {
+ s := v.AuxInt
+ dst := v_0
+ src := v_1
+ mem := v_2
+ if !(s > 16 && s%16 != 0 && s%16 > 8) {
+ break
+ }
+ v.reset(OpMove)
+ v.AuxInt = s - s%16
+ v0 := b.NewValue0(v.Pos, OpOffPtr, dst.Type)
+ v0.AuxInt = s % 16
+ v0.AddArg(dst)
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Pos, OpOffPtr, src.Type)
+ v1.AuxInt = s % 16
+ v1.AddArg(src)
+ v.AddArg(v1)
+ v2 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
+ v2.AuxInt = 8
+ v2.AddArg(dst)
+ v3 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
+ v3.AuxInt = 8
+ v3.AddArg(src)
+ v3.AddArg(mem)
+ v2.AddArg(v3)
+ v4 := b.NewValue0(v.Pos, OpWasmI64Store, types.TypeMem)
+ v4.AddArg(dst)
+ v5 := b.NewValue0(v.Pos, OpWasmI64Load, typ.UInt64)
+ v5.AddArg(src)
+ v5.AddArg(mem)
+ v4.AddArg(v5)
+ v4.AddArg(mem)
+ v2.AddArg(v4)
+ v.AddArg(v2)
return true
}
-}
-func rewriteValueWasm_OpMul8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul8 x y)
- // result: (I64Mul x y)
+ // match: (Move [s] dst src mem)
+ // cond: s%8 == 0
+ // result: (LoweredMove [s/8] dst src mem)
for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Mul)
- v.AddArg(x)
- v.AddArg(y)
+ s := v.AuxInt
+ dst := v_0
+ src := v_1
+ mem := v_2
+ if !(s%8 == 0) {
+ break
+ }
+ v.reset(OpWasmLoweredMove)
+ v.AuxInt = s / 8
+ v.AddArg(dst)
+ v.AddArg(src)
+ v.AddArg(mem)
return true
}
+ return false
}
func rewriteValueWasm_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpNeg32F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Neg32F x)
- // result: (F32Neg x)
- for {
- x := v_0
- v.reset(OpWasmF32Neg)
- v.AddArg(x)
- return true
- }
-}
func rewriteValueWasm_OpNeg64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
return true
}
}
-func rewriteValueWasm_OpNeg64F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Neg64F x)
- // result: (F64Neg x)
- for {
- x := v_0
- v.reset(OpWasmF64Neg)
- v.AddArg(x)
- return true
- }
-}
func rewriteValueWasm_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
return true
}
}
-func rewriteValueWasm_OpNeq32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Neq32F x y)
- // result: (F32Ne x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF32Ne)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpNeq64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Neq64 x y)
- // result: (I64Ne x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Ne)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpNeq64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Neq64F x y)
- // result: (F64Ne x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Ne)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpNeqB(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (NeqB x y)
- // result: (I64Ne x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Ne)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpNeqPtr(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (NeqPtr x y)
- // result: (I64Ne x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Ne)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpNilCheck(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (NilCheck ptr mem)
- // result: (LoweredNilCheck ptr mem)
- for {
- ptr := v_0
- mem := v_1
- v.reset(OpWasmLoweredNilCheck)
- v.AddArg(ptr)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueWasm_OpNot(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Not x)
- // result: (I64Eqz x)
- for {
- x := v_0
- v.reset(OpWasmI64Eqz)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpOffPtr(v *Value) bool {
- v_0 := v.Args[0]
- // match: (OffPtr [off] ptr)
- // result: (I64AddConst [off] ptr)
- for {
- off := v.AuxInt
- ptr := v_0
- v.reset(OpWasmI64AddConst)
- v.AuxInt = off
- v.AddArg(ptr)
- return true
- }
-}
-func rewriteValueWasm_OpOr16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Or16 x y)
- // result: (I64Or x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Or)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpOr32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Or32 x y)
- // result: (I64Or x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Or)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpOr64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Or64 x y)
- // result: (I64Or x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Or)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpOr8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Or8 x y)
- // result: (I64Or x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Or)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpOrB(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (OrB x y)
- // result: (I64Or x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Or)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpPopCount16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
return true
}
}
-func rewriteValueWasm_OpPopCount64(v *Value) bool {
- v_0 := v.Args[0]
- // match: (PopCount64 x)
- // result: (I64Popcnt x)
- for {
- x := v_0
- v.reset(OpWasmI64Popcnt)
- v.AddArg(x)
- return true
- }
-}
func rewriteValueWasm_OpPopCount8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// result: (Or16 (Lsh16x64 <t> x (I64Const [c&15])) (Rsh16Ux64 <t> x (I64Const [-c&15])))
for {
t := v.Type
- x := v_0
- if v_1.Op != OpWasmI64Const {
- break
- }
- c := v_1.AuxInt
- v.reset(OpOr16)
- v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
- v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v1.AuxInt = c & 15
- v0.AddArg(v1)
- v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
- v2.AddArg(x)
- v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
- v3.AuxInt = -c & 15
- v2.AddArg(v3)
- v.AddArg(v2)
- return true
- }
- return false
-}
-func rewriteValueWasm_OpRotateLeft32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (RotateLeft32 x y)
- // result: (I32Rotl x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI32Rotl)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpRotateLeft64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (RotateLeft64 x y)
- // result: (I64Rotl x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Rotl)
- v.AddArg(x)
- v.AddArg(y)
+ x := v_0
+ if v_1.Op != OpWasmI64Const {
+ break
+ }
+ c := v_1.AuxInt
+ v.reset(OpOr16)
+ v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
+ v0.AddArg(x)
+ v1 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v1.AuxInt = c & 15
+ v0.AddArg(v1)
+ v.AddArg(v0)
+ v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
+ v2.AddArg(x)
+ v3 := b.NewValue0(v.Pos, OpWasmI64Const, typ.Int64)
+ v3.AuxInt = -c & 15
+ v2.AddArg(v3)
+ v.AddArg(v2)
return true
}
+ return false
}
func rewriteValueWasm_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
}
return false
}
-func rewriteValueWasm_OpRound32F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Round32F x)
- // result: x
- for {
- x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpRound64F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Round64F x)
- // result: x
- for {
- x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpRoundToEven(v *Value) bool {
- v_0 := v.Args[0]
- // match: (RoundToEven x)
- // result: (F64Nearest x)
- for {
- x := v_0
- v.reset(OpWasmF64Nearest)
- v.AddArg(x)
- return true
- }
-}
func rewriteValueWasm_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueWasm_OpSqrt(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Sqrt x)
- // result: (F64Sqrt x)
- for {
- x := v_0
- v.reset(OpWasmF64Sqrt)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpStaticCall(v *Value) bool {
- v_0 := v.Args[0]
- // match: (StaticCall [argwid] {target} mem)
- // result: (LoweredStaticCall [argwid] {target} mem)
- for {
- argwid := v.AuxInt
- target := v.Aux
- mem := v_0
- v.reset(OpWasmLoweredStaticCall)
- v.AuxInt = argwid
- v.Aux = target
- v.AddArg(mem)
- return true
- }
-}
func rewriteValueWasm_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
}
return false
}
-func rewriteValueWasm_OpSub16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub16 x y)
- // result: (I64Sub x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Sub)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpSub32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub32 x y)
- // result: (I64Sub x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Sub)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpSub32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub32F x y)
- // result: (F32Sub x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF32Sub)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpSub64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub64 x y)
- // result: (I64Sub x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Sub)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpSub64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub64F x y)
- // result: (F64Sub x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmF64Sub)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpSub8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub8 x y)
- // result: (I64Sub x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Sub)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpSubPtr(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (SubPtr x y)
- // result: (I64Sub x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Sub)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpTrunc(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Trunc x)
- // result: (F64Trunc x)
- for {
- x := v_0
- v.reset(OpWasmF64Trunc)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpTrunc16to8(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Trunc16to8 x)
- // result: x
- for {
- x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpTrunc32to16(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Trunc32to16 x)
- // result: x
- for {
- x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpTrunc32to8(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Trunc32to8 x)
- // result: x
- for {
- x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpTrunc64to16(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Trunc64to16 x)
- // result: x
- for {
- x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpTrunc64to32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Trunc64to32 x)
- // result: x
- for {
- x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpTrunc64to8(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Trunc64to8 x)
- // result: x
- for {
- x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueWasm_OpWB(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (WB {fn} destptr srcptr mem)
- // result: (LoweredWB {fn} destptr srcptr mem)
- for {
- fn := v.Aux
- destptr := v_0
- srcptr := v_1
- mem := v_2
- v.reset(OpWasmLoweredWB)
- v.Aux = fn
- v.AddArg(destptr)
- v.AddArg(srcptr)
- v.AddArg(mem)
- return true
- }
-}
func rewriteValueWasm_OpWasmF64Add(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
}
return false
}
-func rewriteValueWasm_OpXor16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Xor16 x y)
- // result: (I64Xor x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Xor)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpXor32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Xor32 x y)
- // result: (I64Xor x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Xor)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpXor64(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Xor64 x y)
- // result: (I64Xor x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Xor)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueWasm_OpXor8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Xor8 x y)
- // result: (I64Xor x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpWasmI64Xor)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueWasm_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]