// 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 <typ.UInt32> (MULLU x y))
(Select1 (Mul32uover x y)) -> (SETO (Select1 <types.TypeFlags> (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 <typ.Float32> [auxFrom32F(float32(math.Copysign(0, -1)))]))
(Neg64F x) && !config.use387 -> (PXOR x (MOVSDconst <typ.Float64> [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 <typ.UInt32> [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 <t> x) -> (XORLconst [-1] (SBBLcarrymask <t> (CMPLconst x [1])))
// 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.
(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
(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)
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:
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:
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:
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:
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:
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:
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:
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)
}
}
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 <typ.UInt32> [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 <typ.UInt32> [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
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]
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]
}
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]
}
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
}
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]
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
}
}
}
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]
}
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)
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]
}
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]
}
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