From 7c0f540b00a7ba7cc723bd7ea27ae90ab72ac09b Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 22 Jan 2020 09:58:43 -0800 Subject: [PATCH] cmd/compile: use ellipses in 386 rules Passes toolstash-check -all. Change-Id: I8ca47b7b7987cb81edaded23331f25c40a8e80dd Reviewed-on: https://go-review.googlesource.com/c/go/+/217004 Run-TryBot: Josh Bleecher Snyder TryBot-Result: Gobot Gobot Reviewed-by: Cherry Zhang --- src/cmd/compile/internal/ssa/gen/386.rules | 123 +- src/cmd/compile/internal/ssa/rewrite386.go | 1680 ++++---------------- 2 files changed, 365 insertions(+), 1438 deletions(-) diff --git a/src/cmd/compile/internal/ssa/gen/386.rules b/src/cmd/compile/internal/ssa/gen/386.rules index 23fbd59b8a..200eedf0fb 100644 --- a/src/cmd/compile/internal/ssa/gen/386.rules +++ b/src/cmd/compile/internal/ssa/gen/386.rules @@ -3,80 +3,71 @@ // license that can be found in the LICENSE file. // Lowering arithmetic -(Add(Ptr|32|16|8) x y) -> (ADDL x y) -(Add(32|64)F x y) -> (ADDS(S|D) x y) -(Add32carry x y) -> (ADDLcarry x y) -(Add32withcarry x y c) -> (ADCL x y c) +(Add(Ptr|32|16|8) ...) -> (ADDL ...) +(Add(32|64)F ...) -> (ADDS(S|D) ...) +(Add32carry ...) -> (ADDLcarry ...) +(Add32withcarry ...) -> (ADCL ...) -(Sub(Ptr|32|16|8) x y) -> (SUBL x y) -(Sub(32|64)F x y) -> (SUBS(S|D) x y) -(Sub32carry x y) -> (SUBLcarry x y) -(Sub32withcarry x y c) -> (SBBL x y c) +(Sub(Ptr|32|16|8) ...) -> (SUBL ...) +(Sub(32|64)F ...) -> (SUBS(S|D) ...) +(Sub32carry ...) -> (SUBLcarry ...) +(Sub32withcarry ...) -> (SBBL ...) -(Mul(32|16|8) x y) -> (MULL x y) -(Mul(32|64)F x y) -> (MULS(S|D) x y) -(Mul32uhilo x y) -> (MULLQU x y) +(Mul(32|16|8) ...) -> (MULL ...) +(Mul(32|64)F ...) -> (MULS(S|D) ...) +(Mul32uhilo ...) -> (MULLQU ...) (Select0 (Mul32uover x y)) -> (Select0 (MULLU x y)) (Select1 (Mul32uover x y)) -> (SETO (Select1 (MULLU x y))) -(Avg32u x y) -> (AVGLU x y) +(Avg32u ...) -> (AVGLU ...) -(Div32F x y) -> (DIVSS x y) -(Div64F x y) -> (DIVSD x y) - -(Div32 [a] x y) -> (DIVL [a] x y) -(Div32u x y) -> (DIVLU x y) -(Div16 [a] x y) -> (DIVW [a] x y) -(Div16u x y) -> (DIVWU x y) +(Div(32|64)F ...) -> (DIVS(S|D) ...) +(Div(32|32u|16|16u) ...) -> (DIV(L|LU|W|WU) ...) (Div8 x y) -> (DIVW (SignExt8to16 x) (SignExt8to16 y)) (Div8u x y) -> (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) -(Hmul32 x y) -> (HMULL x y) -(Hmul32u x y) -> (HMULLU x y) +(Hmul(32|32u) ...) -> (HMUL(L|LU) ...) -(Mod32 [a] x y) -> (MODL [a] x y) -(Mod32u x y) -> (MODLU x y) -(Mod16 [a] x y) -> (MODW [a] x y) -(Mod16u x y) -> (MODWU x y) +(Mod(32|32u|16|16u) ...) -> (MOD(L|LU|W|WU) ...) (Mod8 x y) -> (MODW (SignExt8to16 x) (SignExt8to16 y)) (Mod8u x y) -> (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y)) -(And(32|16|8) x y) -> (ANDL x y) -(Or(32|16|8) x y) -> (ORL x y) -(Xor(32|16|8) x y) -> (XORL x y) +(And(32|16|8) ...) -> (ANDL ...) +(Or(32|16|8) ...) -> (ORL ...) +(Xor(32|16|8) ...) -> (XORL ...) -(Neg(32|16|8) x) -> (NEGL x) +(Neg(32|16|8) ...) -> (NEGL ...) (Neg32F x) && !config.use387 -> (PXOR x (MOVSSconst [auxFrom32F(float32(math.Copysign(0, -1)))])) (Neg64F x) && !config.use387 -> (PXOR x (MOVSDconst [auxFrom64F(math.Copysign(0, -1))])) (Neg32F x) && config.use387 -> (FCHS x) (Neg64F x) && config.use387 -> (FCHS x) -(Com(32|16|8) x) -> (NOTL x) +(Com(32|16|8) ...) -> (NOTL ...) // Lowering boolean ops -(AndB x y) -> (ANDL x y) -(OrB x y) -> (ORL x y) +(AndB ...) -> (ANDL ...) +(OrB ...) -> (ORL ...) (Not x) -> (XORLconst [1] x) // Lowering pointer arithmetic -(OffPtr [off] ptr) -> (ADDLconst [off] ptr) +(OffPtr ...) -> (ADDLconst ...) -(Bswap32 x) -> (BSWAPL x) +(Bswap32 ...) -> (BSWAPL ...) -(Sqrt x) -> (SQRTSD x) +(Sqrt ...) -> (SQRTSD ...) (Ctz16 x) -> (BSFL (ORLconst [0x10000] x)) -(Ctz16NonZero x) -> (BSFL x) +(Ctz16NonZero ...) -> (BSFL ...) // Lowering extension -(SignExt8to16 x) -> (MOVBLSX x) -(SignExt8to32 x) -> (MOVBLSX x) -(SignExt16to32 x) -> (MOVWLSX x) +(SignExt8to16 ...) -> (MOVBLSX ...) +(SignExt8to32 ...) -> (MOVBLSX ...) +(SignExt16to32 ...) -> (MOVWLSX ...) -(ZeroExt8to16 x) -> (MOVBLZX x) -(ZeroExt8to32 x) -> (MOVBLZX x) -(ZeroExt16to32 x) -> (MOVWLZX x) +(ZeroExt8to16 ...) -> (MOVBLZX ...) +(ZeroExt8to32 ...) -> (MOVBLZX ...) +(ZeroExt16to32 ...) -> (MOVWLZX ...) (Signmask x) -> (SARLconst x [31]) (Zeromask x) -> (XORLconst [-1] (SBBLcarrymask (CMPLconst x [1]))) @@ -84,22 +75,22 @@ // Lowering truncation // Because we ignore high parts of registers, truncates are just copies. -(Trunc16to8 x) -> x -(Trunc32to8 x) -> x -(Trunc32to16 x) -> x +(Trunc16to8 ...) -> (Copy ...) +(Trunc32to8 ...) -> (Copy ...) +(Trunc32to16 ...) -> (Copy ...) // Lowering float <-> int -(Cvt32to32F x) -> (CVTSL2SS x) -(Cvt32to64F x) -> (CVTSL2SD x) +(Cvt32to32F ...) -> (CVTSL2SS ...) +(Cvt32to64F ...) -> (CVTSL2SD ...) -(Cvt32Fto32 x) -> (CVTTSS2SL x) -(Cvt64Fto32 x) -> (CVTTSD2SL x) +(Cvt32Fto32 ...) -> (CVTTSS2SL ...) +(Cvt64Fto32 ...) -> (CVTTSD2SL ...) -(Cvt32Fto64F x) -> (CVTSS2SD x) -(Cvt64Fto32F x) -> (CVTSD2SS x) +(Cvt32Fto64F ...) -> (CVTSS2SD ...) +(Cvt64Fto32F ...) -> (CVTSD2SS ...) -(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. @@ -335,26 +326,26 @@ (REPSTOSL destptr (MOVLconst [s/4]) (MOVLconst [0]) mem) // Lowering constants -(Const(8|16|32) [val]) -> (MOVLconst [val]) -(Const(32|64)F [val]) -> (MOVS(S|D)const [val]) +(Const(8|16|32) ...) -> (MOVLconst ...) +(Const(32|64)F ...) -> (MOVS(S|D)const ...) (ConstNil) -> (MOVLconst [0]) -(ConstBool [b]) -> (MOVLconst [b]) +(ConstBool ...) -> (MOVLconst ...) // Lowering calls -(StaticCall [argwid] {target} mem) -> (CALLstatic [argwid] {target} mem) -(ClosureCall [argwid] entry closure mem) -> (CALLclosure [argwid] entry closure mem) -(InterCall [argwid] entry mem) -> (CALLinter [argwid] entry mem) +(StaticCall ...) -> (CALLstatic ...) +(ClosureCall ...) -> (CALLclosure ...) +(InterCall ...) -> (CALLinter ...) // Miscellaneous (IsNonNil p) -> (SETNE (TESTL p p)) (IsInBounds idx len) -> (SETB (CMPL idx len)) (IsSliceInBounds idx len) -> (SETBE (CMPL idx len)) -(NilCheck ptr mem) -> (LoweredNilCheck ptr mem) -(GetG mem) -> (LoweredGetG mem) -(GetClosurePtr) -> (LoweredGetClosurePtr) -(GetCallerPC) -> (LoweredGetCallerPC) -(GetCallerSP) -> (LoweredGetCallerSP) -(Addr {sym} base) -> (LEAL {sym} base) +(NilCheck ...) -> (LoweredNilCheck ...) +(GetG ...) -> (LoweredGetG ...) +(GetClosurePtr ...) -> (LoweredGetClosurePtr ...) +(GetCallerPC ...) -> (LoweredGetCallerPC ...) +(GetCallerSP ...) -> (LoweredGetCallerSP ...) +(Addr ...) -> (LEAL ...) (LocalAddr {sym} base _) -> (LEAL {sym} base) // block rewrites @@ -379,7 +370,7 @@ (If cond yes no) -> (NE (TESTB cond cond) yes no) // Write barrier. -(WB {fn} destptr srcptr mem) -> (LoweredWB {fn} destptr srcptr mem) +(WB ...) -> (LoweredWB ...) (PanicBounds [kind] x y mem) && boundsABI(kind) == 0 -> (LoweredPanicBoundsA [kind] x y mem) (PanicBounds [kind] x y mem) && boundsABI(kind) == 1 -> (LoweredPanicBoundsB [kind] x y mem) diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go index 14a7780f8d..fe92db2bf7 100644 --- a/src/cmd/compile/internal/ssa/rewrite386.go +++ b/src/cmd/compile/internal/ssa/rewrite386.go @@ -309,85 +309,123 @@ func rewriteValue386(v *Value) bool { case Op386XORLmodifyidx4: return rewriteValue386_Op386XORLmodifyidx4(v) case OpAdd16: - return rewriteValue386_OpAdd16(v) + v.Op = Op386ADDL + return true case OpAdd32: - return rewriteValue386_OpAdd32(v) + v.Op = Op386ADDL + return true case OpAdd32F: - return rewriteValue386_OpAdd32F(v) + v.Op = Op386ADDSS + return true case OpAdd32carry: - return rewriteValue386_OpAdd32carry(v) + v.Op = Op386ADDLcarry + return true case OpAdd32withcarry: - return rewriteValue386_OpAdd32withcarry(v) + v.Op = Op386ADCL + return true case OpAdd64F: - return rewriteValue386_OpAdd64F(v) + v.Op = Op386ADDSD + return true case OpAdd8: - return rewriteValue386_OpAdd8(v) + v.Op = Op386ADDL + return true case OpAddPtr: - return rewriteValue386_OpAddPtr(v) + v.Op = Op386ADDL + return true case OpAddr: - return rewriteValue386_OpAddr(v) + v.Op = Op386LEAL + return true case OpAnd16: - return rewriteValue386_OpAnd16(v) + v.Op = Op386ANDL + return true case OpAnd32: - return rewriteValue386_OpAnd32(v) + v.Op = Op386ANDL + return true case OpAnd8: - return rewriteValue386_OpAnd8(v) + v.Op = Op386ANDL + return true case OpAndB: - return rewriteValue386_OpAndB(v) + v.Op = Op386ANDL + return true case OpAvg32u: - return rewriteValue386_OpAvg32u(v) + v.Op = Op386AVGLU + return true case OpBswap32: - return rewriteValue386_OpBswap32(v) + v.Op = Op386BSWAPL + return true case OpClosureCall: - return rewriteValue386_OpClosureCall(v) + v.Op = Op386CALLclosure + return true case OpCom16: - return rewriteValue386_OpCom16(v) + v.Op = Op386NOTL + return true case OpCom32: - return rewriteValue386_OpCom32(v) + v.Op = Op386NOTL + return true case OpCom8: - return rewriteValue386_OpCom8(v) + v.Op = Op386NOTL + return true case OpConst16: - return rewriteValue386_OpConst16(v) + v.Op = Op386MOVLconst + return true case OpConst32: - return rewriteValue386_OpConst32(v) + v.Op = Op386MOVLconst + return true case OpConst32F: - return rewriteValue386_OpConst32F(v) + v.Op = Op386MOVSSconst + return true case OpConst64F: - return rewriteValue386_OpConst64F(v) + v.Op = Op386MOVSDconst + return true case OpConst8: - return rewriteValue386_OpConst8(v) + v.Op = Op386MOVLconst + return true case OpConstBool: - return rewriteValue386_OpConstBool(v) + v.Op = Op386MOVLconst + return true case OpConstNil: return rewriteValue386_OpConstNil(v) case OpCtz16: return rewriteValue386_OpCtz16(v) case OpCtz16NonZero: - return rewriteValue386_OpCtz16NonZero(v) + v.Op = Op386BSFL + return true case OpCvt32Fto32: - return rewriteValue386_OpCvt32Fto32(v) + v.Op = Op386CVTTSS2SL + return true case OpCvt32Fto64F: - return rewriteValue386_OpCvt32Fto64F(v) + v.Op = Op386CVTSS2SD + return true case OpCvt32to32F: - return rewriteValue386_OpCvt32to32F(v) + v.Op = Op386CVTSL2SS + return true case OpCvt32to64F: - return rewriteValue386_OpCvt32to64F(v) + v.Op = Op386CVTSL2SD + return true case OpCvt64Fto32: - return rewriteValue386_OpCvt64Fto32(v) + v.Op = Op386CVTTSD2SL + return true case OpCvt64Fto32F: - return rewriteValue386_OpCvt64Fto32F(v) + v.Op = Op386CVTSD2SS + return true case OpDiv16: - return rewriteValue386_OpDiv16(v) + v.Op = Op386DIVW + return true case OpDiv16u: - return rewriteValue386_OpDiv16u(v) + v.Op = Op386DIVWU + return true case OpDiv32: - return rewriteValue386_OpDiv32(v) + v.Op = Op386DIVL + return true case OpDiv32F: - return rewriteValue386_OpDiv32F(v) + v.Op = Op386DIVSS + return true case OpDiv32u: - return rewriteValue386_OpDiv32u(v) + v.Op = Op386DIVLU + return true case OpDiv64F: - return rewriteValue386_OpDiv64F(v) + v.Op = Op386DIVSD + return true case OpDiv8: return rewriteValue386_OpDiv8(v) case OpDiv8u: @@ -423,13 +461,17 @@ func rewriteValue386(v *Value) bool { case OpGeq8U: return rewriteValue386_OpGeq8U(v) case OpGetCallerPC: - return rewriteValue386_OpGetCallerPC(v) + v.Op = Op386LoweredGetCallerPC + return true case OpGetCallerSP: - return rewriteValue386_OpGetCallerSP(v) + v.Op = Op386LoweredGetCallerSP + return true case OpGetClosurePtr: - return rewriteValue386_OpGetClosurePtr(v) + v.Op = Op386LoweredGetClosurePtr + return true case OpGetG: - return rewriteValue386_OpGetG(v) + v.Op = Op386LoweredGetG + return true case OpGreater16: return rewriteValue386_OpGreater16(v) case OpGreater16U: @@ -447,11 +489,14 @@ func rewriteValue386(v *Value) bool { case OpGreater8U: return rewriteValue386_OpGreater8U(v) case OpHmul32: - return rewriteValue386_OpHmul32(v) + v.Op = Op386HMULL + return true case OpHmul32u: - return rewriteValue386_OpHmul32u(v) + v.Op = Op386HMULLU + return true case OpInterCall: - return rewriteValue386_OpInterCall(v) + v.Op = Op386CALLinter + return true case OpIsInBounds: return rewriteValue386_OpIsInBounds(v) case OpIsNonNil: @@ -519,13 +564,17 @@ func rewriteValue386(v *Value) bool { case OpLsh8x8: return rewriteValue386_OpLsh8x8(v) case OpMod16: - return rewriteValue386_OpMod16(v) + v.Op = Op386MODW + return true case OpMod16u: - return rewriteValue386_OpMod16u(v) + v.Op = Op386MODWU + return true case OpMod32: - return rewriteValue386_OpMod32(v) + v.Op = Op386MODL + return true case OpMod32u: - return rewriteValue386_OpMod32u(v) + v.Op = Op386MODLU + return true case OpMod8: return rewriteValue386_OpMod8(v) case OpMod8u: @@ -533,27 +582,36 @@ func rewriteValue386(v *Value) bool { case OpMove: return rewriteValue386_OpMove(v) case OpMul16: - return rewriteValue386_OpMul16(v) + v.Op = Op386MULL + return true case OpMul32: - return rewriteValue386_OpMul32(v) + v.Op = Op386MULL + return true case OpMul32F: - return rewriteValue386_OpMul32F(v) + v.Op = Op386MULSS + return true case OpMul32uhilo: - return rewriteValue386_OpMul32uhilo(v) + v.Op = Op386MULLQU + return true case OpMul64F: - return rewriteValue386_OpMul64F(v) + v.Op = Op386MULSD + return true case OpMul8: - return rewriteValue386_OpMul8(v) + v.Op = Op386MULL + return true case OpNeg16: - return rewriteValue386_OpNeg16(v) + v.Op = Op386NEGL + return true case OpNeg32: - return rewriteValue386_OpNeg32(v) + v.Op = Op386NEGL + return true case OpNeg32F: return rewriteValue386_OpNeg32F(v) case OpNeg64F: return rewriteValue386_OpNeg64F(v) case OpNeg8: - return rewriteValue386_OpNeg8(v) + v.Op = Op386NEGL + return true case OpNeq16: return rewriteValue386_OpNeq16(v) case OpNeq32: @@ -569,19 +627,25 @@ func rewriteValue386(v *Value) bool { case OpNeqPtr: return rewriteValue386_OpNeqPtr(v) case OpNilCheck: - return rewriteValue386_OpNilCheck(v) + v.Op = Op386LoweredNilCheck + return true case OpNot: return rewriteValue386_OpNot(v) case OpOffPtr: - return rewriteValue386_OpOffPtr(v) + v.Op = Op386ADDLconst + return true case OpOr16: - return rewriteValue386_OpOr16(v) + v.Op = Op386ORL + return true case OpOr32: - return rewriteValue386_OpOr32(v) + v.Op = Op386ORL + return true case OpOr8: - return rewriteValue386_OpOr8(v) + v.Op = Op386ORL + return true case OpOrB: - return rewriteValue386_OpOrB(v) + v.Op = Op386ORL + return true case OpPanicBounds: return rewriteValue386_OpPanicBounds(v) case OpPanicExtend: @@ -593,9 +657,11 @@ func rewriteValue386(v *Value) bool { case OpRotateLeft8: return rewriteValue386_OpRotateLeft8(v) case OpRound32F: - return rewriteValue386_OpRound32F(v) + v.Op = OpCopy + return true case OpRound64F: - return rewriteValue386_OpRound64F(v) + v.Op = OpCopy + return true case OpRsh16Ux16: return rewriteValue386_OpRsh16Ux16(v) case OpRsh16Ux32: @@ -649,59 +715,82 @@ func rewriteValue386(v *Value) bool { case OpSelect1: return rewriteValue386_OpSelect1(v) case OpSignExt16to32: - return rewriteValue386_OpSignExt16to32(v) + v.Op = Op386MOVWLSX + return true case OpSignExt8to16: - return rewriteValue386_OpSignExt8to16(v) + v.Op = Op386MOVBLSX + return true case OpSignExt8to32: - return rewriteValue386_OpSignExt8to32(v) + v.Op = Op386MOVBLSX + return true case OpSignmask: return rewriteValue386_OpSignmask(v) case OpSlicemask: return rewriteValue386_OpSlicemask(v) case OpSqrt: - return rewriteValue386_OpSqrt(v) + v.Op = Op386SQRTSD + return true case OpStaticCall: - return rewriteValue386_OpStaticCall(v) + v.Op = Op386CALLstatic + return true case OpStore: return rewriteValue386_OpStore(v) case OpSub16: - return rewriteValue386_OpSub16(v) + v.Op = Op386SUBL + return true case OpSub32: - return rewriteValue386_OpSub32(v) + v.Op = Op386SUBL + return true case OpSub32F: - return rewriteValue386_OpSub32F(v) + v.Op = Op386SUBSS + return true case OpSub32carry: - return rewriteValue386_OpSub32carry(v) + v.Op = Op386SUBLcarry + return true case OpSub32withcarry: - return rewriteValue386_OpSub32withcarry(v) + v.Op = Op386SBBL + return true case OpSub64F: - return rewriteValue386_OpSub64F(v) + v.Op = Op386SUBSD + return true case OpSub8: - return rewriteValue386_OpSub8(v) + v.Op = Op386SUBL + return true case OpSubPtr: - return rewriteValue386_OpSubPtr(v) + v.Op = Op386SUBL + return true case OpTrunc16to8: - return rewriteValue386_OpTrunc16to8(v) + v.Op = OpCopy + return true case OpTrunc32to16: - return rewriteValue386_OpTrunc32to16(v) + v.Op = OpCopy + return true case OpTrunc32to8: - return rewriteValue386_OpTrunc32to8(v) + v.Op = OpCopy + return true case OpWB: - return rewriteValue386_OpWB(v) + v.Op = Op386LoweredWB + return true case OpXor16: - return rewriteValue386_OpXor16(v) + v.Op = Op386XORL + return true case OpXor32: - return rewriteValue386_OpXor32(v) + v.Op = Op386XORL + return true case OpXor8: - return rewriteValue386_OpXor8(v) + v.Op = Op386XORL + return true case OpZero: return rewriteValue386_OpZero(v) case OpZeroExt16to32: - return rewriteValue386_OpZeroExt16to32(v) + v.Op = Op386MOVWLZX + return true case OpZeroExt8to16: - return rewriteValue386_OpZeroExt8to16(v) + v.Op = Op386MOVBLZX + return true case OpZeroExt8to32: - return rewriteValue386_OpZeroExt8to32(v) + v.Op = Op386MOVBLZX + return true case OpZeromask: return rewriteValue386_OpZeromask(v) } @@ -13529,711 +13618,225 @@ func rewriteValue386_Op386XORLmodifyidx4(v *Value) bool { } return false } -func rewriteValue386_OpAdd16(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Add16 x y) - // result: (ADDL x y) +func rewriteValue386_OpConstNil(v *Value) bool { + // match: (ConstNil) + // result: (MOVLconst [0]) for { - x := v_0 - y := v_1 - v.reset(Op386ADDL) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386MOVLconst) + v.AuxInt = 0 return true } } -func rewriteValue386_OpAdd32(v *Value) bool { - v_1 := v.Args[1] +func rewriteValue386_OpCtz16(v *Value) bool { v_0 := v.Args[0] - // match: (Add32 x y) - // result: (ADDL x y) + b := v.Block + typ := &b.Func.Config.Types + // match: (Ctz16 x) + // result: (BSFL (ORLconst [0x10000] x)) for { x := v_0 - y := v_1 - v.reset(Op386ADDL) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386BSFL) + v0 := b.NewValue0(v.Pos, Op386ORLconst, typ.UInt32) + v0.AuxInt = 0x10000 + v0.AddArg(x) + v.AddArg(v0) return true } } -func rewriteValue386_OpAdd32F(v *Value) bool { +func rewriteValue386_OpDiv8(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (Add32F x y) - // result: (ADDSS x y) + b := v.Block + typ := &b.Func.Config.Types + // match: (Div8 x y) + // result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) for { x := v_0 y := v_1 - v.reset(Op386ADDSS) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386DIVW) + v0 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16) + v0.AddArg(x) + v.AddArg(v0) + v1 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16) + v1.AddArg(y) + v.AddArg(v1) return true } } -func rewriteValue386_OpAdd32carry(v *Value) bool { +func rewriteValue386_OpDiv8u(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (Add32carry x y) - // result: (ADDLcarry x y) + b := v.Block + typ := &b.Func.Config.Types + // match: (Div8u x y) + // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) for { x := v_0 y := v_1 - v.reset(Op386ADDLcarry) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386DIVWU) + v0 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16) + v0.AddArg(x) + v.AddArg(v0) + v1 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16) + v1.AddArg(y) + v.AddArg(v1) return true } } -func rewriteValue386_OpAdd32withcarry(v *Value) bool { - v_2 := v.Args[2] +func rewriteValue386_OpEq16(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (Add32withcarry x y c) - // result: (ADCL x y c) + b := v.Block + // match: (Eq16 x y) + // result: (SETEQ (CMPW x y)) for { x := v_0 y := v_1 - c := v_2 - v.reset(Op386ADCL) - v.AddArg(x) - v.AddArg(y) - v.AddArg(c) + v.reset(Op386SETEQ) + v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpAdd64F(v *Value) bool { +func rewriteValue386_OpEq32(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (Add64F x y) - // result: (ADDSD x y) + b := v.Block + // match: (Eq32 x y) + // result: (SETEQ (CMPL x y)) for { x := v_0 y := v_1 - v.reset(Op386ADDSD) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386SETEQ) + v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpAdd8(v *Value) bool { +func rewriteValue386_OpEq32F(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (Add8 x y) - // result: (ADDL x y) + b := v.Block + // match: (Eq32F x y) + // result: (SETEQF (UCOMISS x y)) for { x := v_0 y := v_1 - v.reset(Op386ADDL) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386SETEQF) + v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags) + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpAddPtr(v *Value) bool { +func rewriteValue386_OpEq64F(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (AddPtr x y) - // result: (ADDL x y) + b := v.Block + // match: (Eq64F x y) + // result: (SETEQF (UCOMISD x y)) for { x := v_0 y := v_1 - v.reset(Op386ADDL) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386SETEQF) + v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags) + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpAddr(v *Value) bool { +func rewriteValue386_OpEq8(v *Value) bool { + v_1 := v.Args[1] v_0 := v.Args[0] - // match: (Addr {sym} base) - // result: (LEAL {sym} base) + b := v.Block + // match: (Eq8 x y) + // result: (SETEQ (CMPB x y)) for { - sym := v.Aux - base := v_0 - v.reset(Op386LEAL) - v.Aux = sym - v.AddArg(base) + x := v_0 + y := v_1 + v.reset(Op386SETEQ) + v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpAnd16(v *Value) bool { +func rewriteValue386_OpEqB(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (And16 x y) - // result: (ANDL x y) + b := v.Block + // match: (EqB x y) + // result: (SETEQ (CMPB x y)) for { x := v_0 y := v_1 - v.reset(Op386ANDL) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386SETEQ) + v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpAnd32(v *Value) bool { +func rewriteValue386_OpEqPtr(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (And32 x y) - // result: (ANDL x y) + b := v.Block + // match: (EqPtr x y) + // result: (SETEQ (CMPL x y)) for { x := v_0 y := v_1 - v.reset(Op386ANDL) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386SETEQ) + v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpAnd8(v *Value) bool { +func rewriteValue386_OpGeq16(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (And8 x y) - // result: (ANDL x y) + b := v.Block + // match: (Geq16 x y) + // result: (SETGE (CMPW x y)) for { x := v_0 y := v_1 - v.reset(Op386ANDL) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386SETGE) + v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpAndB(v *Value) bool { +func rewriteValue386_OpGeq16U(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] - // match: (AndB x y) - // result: (ANDL x y) + b := v.Block + // match: (Geq16U x y) + // result: (SETAE (CMPW x y)) for { x := v_0 y := v_1 - v.reset(Op386ANDL) - v.AddArg(x) - v.AddArg(y) + v.reset(Op386SETAE) + v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpAvg32u(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Avg32u x y) - // result: (AVGLU x y) - for { - x := v_0 - y := v_1 - v.reset(Op386AVGLU) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpBswap32(v *Value) bool { - v_0 := v.Args[0] - // match: (Bswap32 x) - // result: (BSWAPL x) - for { - x := v_0 - v.reset(Op386BSWAPL) - v.AddArg(x) - return true - } -} -func rewriteValue386_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: (CALLclosure [argwid] entry closure mem) - for { - argwid := v.AuxInt - entry := v_0 - closure := v_1 - mem := v_2 - v.reset(Op386CALLclosure) - v.AuxInt = argwid - v.AddArg(entry) - v.AddArg(closure) - v.AddArg(mem) - return true - } -} -func rewriteValue386_OpCom16(v *Value) bool { - v_0 := v.Args[0] - // match: (Com16 x) - // result: (NOTL x) - for { - x := v_0 - v.reset(Op386NOTL) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpCom32(v *Value) bool { - v_0 := v.Args[0] - // match: (Com32 x) - // result: (NOTL x) - for { - x := v_0 - v.reset(Op386NOTL) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpCom8(v *Value) bool { - v_0 := v.Args[0] - // match: (Com8 x) - // result: (NOTL x) - for { - x := v_0 - v.reset(Op386NOTL) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpConst16(v *Value) bool { - // match: (Const16 [val]) - // result: (MOVLconst [val]) - for { - val := v.AuxInt - v.reset(Op386MOVLconst) - v.AuxInt = val - return true - } -} -func rewriteValue386_OpConst32(v *Value) bool { - // match: (Const32 [val]) - // result: (MOVLconst [val]) - for { - val := v.AuxInt - v.reset(Op386MOVLconst) - v.AuxInt = val - return true - } -} -func rewriteValue386_OpConst32F(v *Value) bool { - // match: (Const32F [val]) - // result: (MOVSSconst [val]) - for { - val := v.AuxInt - v.reset(Op386MOVSSconst) - v.AuxInt = val - return true - } -} -func rewriteValue386_OpConst64F(v *Value) bool { - // match: (Const64F [val]) - // result: (MOVSDconst [val]) - for { - val := v.AuxInt - v.reset(Op386MOVSDconst) - v.AuxInt = val - return true - } -} -func rewriteValue386_OpConst8(v *Value) bool { - // match: (Const8 [val]) - // result: (MOVLconst [val]) - for { - val := v.AuxInt - v.reset(Op386MOVLconst) - v.AuxInt = val - return true - } -} -func rewriteValue386_OpConstBool(v *Value) bool { - // match: (ConstBool [b]) - // result: (MOVLconst [b]) - for { - b := v.AuxInt - v.reset(Op386MOVLconst) - v.AuxInt = b - return true - } -} -func rewriteValue386_OpConstNil(v *Value) bool { - // match: (ConstNil) - // result: (MOVLconst [0]) - for { - v.reset(Op386MOVLconst) - v.AuxInt = 0 - return true - } -} -func rewriteValue386_OpCtz16(v *Value) bool { - v_0 := v.Args[0] - b := v.Block - typ := &b.Func.Config.Types - // match: (Ctz16 x) - // result: (BSFL (ORLconst [0x10000] x)) - for { - x := v_0 - v.reset(Op386BSFL) - v0 := b.NewValue0(v.Pos, Op386ORLconst, typ.UInt32) - v0.AuxInt = 0x10000 - v0.AddArg(x) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpCtz16NonZero(v *Value) bool { - v_0 := v.Args[0] - // match: (Ctz16NonZero x) - // result: (BSFL x) - for { - x := v_0 - v.reset(Op386BSFL) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpCvt32Fto32(v *Value) bool { - v_0 := v.Args[0] - // match: (Cvt32Fto32 x) - // result: (CVTTSS2SL x) - for { - x := v_0 - v.reset(Op386CVTTSS2SL) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpCvt32Fto64F(v *Value) bool { - v_0 := v.Args[0] - // match: (Cvt32Fto64F x) - // result: (CVTSS2SD x) - for { - x := v_0 - v.reset(Op386CVTSS2SD) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpCvt32to32F(v *Value) bool { - v_0 := v.Args[0] - // match: (Cvt32to32F x) - // result: (CVTSL2SS x) - for { - x := v_0 - v.reset(Op386CVTSL2SS) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpCvt32to64F(v *Value) bool { - v_0 := v.Args[0] - // match: (Cvt32to64F x) - // result: (CVTSL2SD x) - for { - x := v_0 - v.reset(Op386CVTSL2SD) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpCvt64Fto32(v *Value) bool { - v_0 := v.Args[0] - // match: (Cvt64Fto32 x) - // result: (CVTTSD2SL x) - for { - x := v_0 - v.reset(Op386CVTTSD2SL) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpCvt64Fto32F(v *Value) bool { - v_0 := v.Args[0] - // match: (Cvt64Fto32F x) - // result: (CVTSD2SS x) - for { - x := v_0 - v.reset(Op386CVTSD2SS) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpDiv16(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Div16 [a] x y) - // result: (DIVW [a] x y) - for { - a := v.AuxInt - x := v_0 - y := v_1 - v.reset(Op386DIVW) - v.AuxInt = a - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpDiv16u(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Div16u x y) - // result: (DIVWU x y) - for { - x := v_0 - y := v_1 - v.reset(Op386DIVWU) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpDiv32(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Div32 [a] x y) - // result: (DIVL [a] x y) - for { - a := v.AuxInt - x := v_0 - y := v_1 - v.reset(Op386DIVL) - v.AuxInt = a - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpDiv32F(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Div32F x y) - // result: (DIVSS x y) - for { - x := v_0 - y := v_1 - v.reset(Op386DIVSS) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpDiv32u(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Div32u x y) - // result: (DIVLU x y) - for { - x := v_0 - y := v_1 - v.reset(Op386DIVLU) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpDiv64F(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Div64F x y) - // result: (DIVSD x y) - for { - x := v_0 - y := v_1 - v.reset(Op386DIVSD) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpDiv8(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - typ := &b.Func.Config.Types - // match: (Div8 x y) - // result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) - for { - x := v_0 - y := v_1 - v.reset(Op386DIVW) - v0 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16) - v0.AddArg(x) - v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16) - v1.AddArg(y) - v.AddArg(v1) - return true - } -} -func rewriteValue386_OpDiv8u(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - typ := &b.Func.Config.Types - // match: (Div8u x y) - // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) - for { - x := v_0 - y := v_1 - v.reset(Op386DIVWU) - v0 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16) - v0.AddArg(x) - v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16) - v1.AddArg(y) - v.AddArg(v1) - return true - } -} -func rewriteValue386_OpEq16(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - // match: (Eq16 x y) - // result: (SETEQ (CMPW x y)) - for { - x := v_0 - y := v_1 - v.reset(Op386SETEQ) - v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpEq32(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - // match: (Eq32 x y) - // result: (SETEQ (CMPL x y)) - for { - x := v_0 - y := v_1 - v.reset(Op386SETEQ) - v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpEq32F(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - // match: (Eq32F x y) - // result: (SETEQF (UCOMISS x y)) - for { - x := v_0 - y := v_1 - v.reset(Op386SETEQF) - v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags) - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpEq64F(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - // match: (Eq64F x y) - // result: (SETEQF (UCOMISD x y)) - for { - x := v_0 - y := v_1 - v.reset(Op386SETEQF) - v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags) - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpEq8(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - // match: (Eq8 x y) - // result: (SETEQ (CMPB x y)) - for { - x := v_0 - y := v_1 - v.reset(Op386SETEQ) - v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpEqB(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - // match: (EqB x y) - // result: (SETEQ (CMPB x y)) - for { - x := v_0 - y := v_1 - v.reset(Op386SETEQ) - v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpEqPtr(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - // match: (EqPtr x y) - // result: (SETEQ (CMPL x y)) - for { - x := v_0 - y := v_1 - v.reset(Op386SETEQ) - v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpGeq16(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - // match: (Geq16 x y) - // result: (SETGE (CMPW x y)) - for { - x := v_0 - y := v_1 - v.reset(Op386SETGE) - v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpGeq16U(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - b := v.Block - // match: (Geq16U x y) - // result: (SETAE (CMPW x y)) - for { - x := v_0 - y := v_1 - v.reset(Op386SETAE) - v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_OpGeq32(v *Value) bool { +func rewriteValue386_OpGeq32(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] b := v.Block @@ -14335,41 +13938,6 @@ func rewriteValue386_OpGeq8U(v *Value) bool { return true } } -func rewriteValue386_OpGetCallerPC(v *Value) bool { - // match: (GetCallerPC) - // result: (LoweredGetCallerPC) - for { - v.reset(Op386LoweredGetCallerPC) - return true - } -} -func rewriteValue386_OpGetCallerSP(v *Value) bool { - // match: (GetCallerSP) - // result: (LoweredGetCallerSP) - for { - v.reset(Op386LoweredGetCallerSP) - return true - } -} -func rewriteValue386_OpGetClosurePtr(v *Value) bool { - // match: (GetClosurePtr) - // result: (LoweredGetClosurePtr) - for { - v.reset(Op386LoweredGetClosurePtr) - return true - } -} -func rewriteValue386_OpGetG(v *Value) bool { - v_0 := v.Args[0] - // match: (GetG mem) - // result: (LoweredGetG mem) - for { - mem := v_0 - v.reset(Op386LoweredGetG) - v.AddArg(mem) - return true - } -} func rewriteValue386_OpGreater16(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] @@ -14506,50 +14074,6 @@ func rewriteValue386_OpGreater8U(v *Value) bool { return true } } -func rewriteValue386_OpHmul32(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Hmul32 x y) - // result: (HMULL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386HMULL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpHmul32u(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Hmul32u x y) - // result: (HMULLU x y) - for { - x := v_0 - y := v_1 - v.reset(Op386HMULLU) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpInterCall(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (InterCall [argwid] entry mem) - // result: (CALLinter [argwid] entry mem) - for { - argwid := v.AuxInt - entry := v_0 - mem := v_1 - v.reset(Op386CALLinter) - v.AuxInt = argwid - v.AddArg(entry) - v.AddArg(mem) - return true - } -} func rewriteValue386_OpIsInBounds(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] @@ -15480,66 +15004,6 @@ func rewriteValue386_OpLsh8x8(v *Value) bool { } return false } -func rewriteValue386_OpMod16(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mod16 [a] x y) - // result: (MODW [a] x y) - for { - a := v.AuxInt - x := v_0 - y := v_1 - v.reset(Op386MODW) - v.AuxInt = a - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpMod16u(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mod16u x y) - // result: (MODWU x y) - for { - x := v_0 - y := v_1 - v.reset(Op386MODWU) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpMod32(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mod32 [a] x y) - // result: (MODL [a] x y) - for { - a := v.AuxInt - x := v_0 - y := v_1 - v.reset(Op386MODL) - v.AuxInt = a - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpMod32u(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mod32u x y) - // result: (MODLU x y) - for { - x := v_0 - y := v_1 - v.reset(Op386MODLU) - v.AddArg(x) - v.AddArg(y) - return true - } -} func rewriteValue386_OpMod8(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] @@ -15859,112 +15323,6 @@ func rewriteValue386_OpMove(v *Value) bool { } return false } -func rewriteValue386_OpMul16(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mul16 x y) - // result: (MULL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386MULL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpMul32(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mul32 x y) - // result: (MULL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386MULL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpMul32F(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mul32F x y) - // result: (MULSS x y) - for { - x := v_0 - y := v_1 - v.reset(Op386MULSS) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpMul32uhilo(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mul32uhilo x y) - // result: (MULLQU x y) - for { - x := v_0 - y := v_1 - v.reset(Op386MULLQU) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpMul64F(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mul64F x y) - // result: (MULSD x y) - for { - x := v_0 - y := v_1 - v.reset(Op386MULSD) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpMul8(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Mul8 x y) - // result: (MULL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386MULL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpNeg16(v *Value) bool { - v_0 := v.Args[0] - // match: (Neg16 x) - // result: (NEGL x) - for { - x := v_0 - v.reset(Op386NEGL) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpNeg32(v *Value) bool { - v_0 := v.Args[0] - // match: (Neg32 x) - // result: (NEGL x) - for { - x := v_0 - v.reset(Op386NEGL) - v.AddArg(x) - return true - } -} func rewriteValue386_OpNeg32F(v *Value) bool { v_0 := v.Args[0] b := v.Block @@ -16033,17 +15391,6 @@ func rewriteValue386_OpNeg64F(v *Value) bool { } return false } -func rewriteValue386_OpNeg8(v *Value) bool { - v_0 := v.Args[0] - // match: (Neg8 x) - // result: (NEGL x) - for { - x := v_0 - v.reset(Op386NEGL) - v.AddArg(x) - return true - } -} func rewriteValue386_OpNeq16(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] @@ -16159,102 +15506,19 @@ func rewriteValue386_OpNeqPtr(v *Value) bool { v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) v0.AddArg(x) v0.AddArg(y) - v.AddArg(v0) - return true - } -} -func rewriteValue386_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(Op386LoweredNilCheck) - v.AddArg(ptr) - v.AddArg(mem) - return true - } -} -func rewriteValue386_OpNot(v *Value) bool { - v_0 := v.Args[0] - // match: (Not x) - // result: (XORLconst [1] x) - for { - x := v_0 - v.reset(Op386XORLconst) - v.AuxInt = 1 - v.AddArg(x) - return true - } -} -func rewriteValue386_OpOffPtr(v *Value) bool { - v_0 := v.Args[0] - // match: (OffPtr [off] ptr) - // result: (ADDLconst [off] ptr) - for { - off := v.AuxInt - ptr := v_0 - v.reset(Op386ADDLconst) - v.AuxInt = off - v.AddArg(ptr) - return true - } -} -func rewriteValue386_OpOr16(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Or16 x y) - // result: (ORL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386ORL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpOr32(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Or32 x y) - // result: (ORL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386ORL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpOr8(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Or8 x y) - // result: (ORL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386ORL) - v.AddArg(x) - v.AddArg(y) + v.AddArg(v0) return true } } -func rewriteValue386_OpOrB(v *Value) bool { - v_1 := v.Args[1] +func rewriteValue386_OpNot(v *Value) bool { v_0 := v.Args[0] - // match: (OrB x y) - // result: (ORL x y) + // match: (Not x) + // result: (XORLconst [1] x) for { x := v_0 - y := v_1 - v.reset(Op386ORL) + v.reset(Op386XORLconst) + v.AuxInt = 1 v.AddArg(x) - v.AddArg(y) return true } } @@ -16439,30 +15703,6 @@ func rewriteValue386_OpRotateLeft8(v *Value) bool { } return false } -func rewriteValue386_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 rewriteValue386_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 rewriteValue386_OpRsh16Ux16(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] @@ -17555,39 +16795,6 @@ func rewriteValue386_OpSelect1(v *Value) bool { } return false } -func rewriteValue386_OpSignExt16to32(v *Value) bool { - v_0 := v.Args[0] - // match: (SignExt16to32 x) - // result: (MOVWLSX x) - for { - x := v_0 - v.reset(Op386MOVWLSX) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpSignExt8to16(v *Value) bool { - v_0 := v.Args[0] - // match: (SignExt8to16 x) - // result: (MOVBLSX x) - for { - x := v_0 - v.reset(Op386MOVBLSX) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpSignExt8to32(v *Value) bool { - v_0 := v.Args[0] - // match: (SignExt8to32 x) - // result: (MOVBLSX x) - for { - x := v_0 - v.reset(Op386MOVBLSX) - v.AddArg(x) - return true - } -} func rewriteValue386_OpSignmask(v *Value) bool { v_0 := v.Args[0] // match: (Signmask x) @@ -17616,32 +16823,6 @@ func rewriteValue386_OpSlicemask(v *Value) bool { return true } } -func rewriteValue386_OpSqrt(v *Value) bool { - v_0 := v.Args[0] - // match: (Sqrt x) - // result: (SQRTSD x) - for { - x := v_0 - v.reset(Op386SQRTSD) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpStaticCall(v *Value) bool { - v_0 := v.Args[0] - // match: (StaticCall [argwid] {target} mem) - // result: (CALLstatic [argwid] {target} mem) - for { - argwid := v.AuxInt - target := v.Aux - mem := v_0 - v.reset(Op386CALLstatic) - v.AuxInt = argwid - v.Aux = target - v.AddArg(mem) - return true - } -} func rewriteValue386_OpStore(v *Value) bool { v_2 := v.Args[2] v_1 := v.Args[1] @@ -17733,218 +16914,6 @@ func rewriteValue386_OpStore(v *Value) bool { } return false } -func rewriteValue386_OpSub16(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Sub16 x y) - // result: (SUBL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386SUBL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpSub32(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Sub32 x y) - // result: (SUBL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386SUBL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpSub32F(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Sub32F x y) - // result: (SUBSS x y) - for { - x := v_0 - y := v_1 - v.reset(Op386SUBSS) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpSub32carry(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Sub32carry x y) - // result: (SUBLcarry x y) - for { - x := v_0 - y := v_1 - v.reset(Op386SUBLcarry) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpSub32withcarry(v *Value) bool { - v_2 := v.Args[2] - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Sub32withcarry x y c) - // result: (SBBL x y c) - for { - x := v_0 - y := v_1 - c := v_2 - v.reset(Op386SBBL) - v.AddArg(x) - v.AddArg(y) - v.AddArg(c) - return true - } -} -func rewriteValue386_OpSub64F(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Sub64F x y) - // result: (SUBSD x y) - for { - x := v_0 - y := v_1 - v.reset(Op386SUBSD) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpSub8(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Sub8 x y) - // result: (SUBL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386SUBL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpSubPtr(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (SubPtr x y) - // result: (SUBL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386SUBL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_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 rewriteValue386_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 rewriteValue386_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 rewriteValue386_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(Op386LoweredWB) - v.Aux = fn - v.AddArg(destptr) - v.AddArg(srcptr) - v.AddArg(mem) - return true - } -} -func rewriteValue386_OpXor16(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Xor16 x y) - // result: (XORL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386XORL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpXor32(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Xor32 x y) - // result: (XORL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386XORL) - v.AddArg(x) - v.AddArg(y) - return true - } -} -func rewriteValue386_OpXor8(v *Value) bool { - v_1 := v.Args[1] - v_0 := v.Args[0] - // match: (Xor8 x y) - // result: (XORL x y) - for { - x := v_0 - y := v_1 - v.reset(Op386XORL) - v.AddArg(x) - v.AddArg(y) - return true - } -} func rewriteValue386_OpZero(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] @@ -18208,39 +17177,6 @@ func rewriteValue386_OpZero(v *Value) bool { } return false } -func rewriteValue386_OpZeroExt16to32(v *Value) bool { - v_0 := v.Args[0] - // match: (ZeroExt16to32 x) - // result: (MOVWLZX x) - for { - x := v_0 - v.reset(Op386MOVWLZX) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpZeroExt8to16(v *Value) bool { - v_0 := v.Args[0] - // match: (ZeroExt8to16 x) - // result: (MOVBLZX x) - for { - x := v_0 - v.reset(Op386MOVBLZX) - v.AddArg(x) - return true - } -} -func rewriteValue386_OpZeroExt8to32(v *Value) bool { - v_0 := v.Args[0] - // match: (ZeroExt8to32 x) - // result: (MOVBLZX x) - for { - x := v_0 - v.reset(Op386MOVBLZX) - v.AddArg(x) - return true - } -} func rewriteValue386_OpZeromask(v *Value) bool { v_0 := v.Args[0] b := v.Block -- 2.50.0