// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-(Add(Ptr|32|16|8) x y) -> (ADD x y)
-(Add(32|64)F x y) -> (ADD(F|D) x y)
+(Add(Ptr|32|16|8) ...) -> (ADD ...)
+(Add(32|64)F ...) -> (ADD(F|D) ...)
(Select0 (Add32carry <t> x y)) -> (ADD <t.FieldType(0)> x y)
(Select1 (Add32carry <t> x y)) -> (SGTU <typ.Bool> x (ADD <t.FieldType(0)> x y))
(Add32withcarry <t> x y c) -> (ADD c (ADD <t> x y))
-(Sub(Ptr|32|16|8) x y) -> (SUB x y)
-(Sub(32|64)F x y) -> (SUB(F|D) x y)
+(Sub(Ptr|32|16|8) ...) -> (SUB ...)
+(Sub(32|64)F ...) -> (SUB(F|D) ...)
(Select0 (Sub32carry <t> x y)) -> (SUB <t.FieldType(0)> x y)
(Select1 (Sub32carry <t> x y)) -> (SGTU <typ.Bool> (SUB <t.FieldType(0)> x y) x)
(Sub32withcarry <t> x y c) -> (SUB (SUB <t> x y) c)
-(Mul(32|16|8) x y) -> (MUL x y)
-(Mul(32|64)F x y) -> (MUL(F|D) x y)
+(Mul(32|16|8) ...) -> (MUL ...)
+(Mul(32|64)F ...) -> (MUL(F|D) ...)
(Hmul(32|32u) x y) -> (Select0 (MUL(T|TU) x y))
-(Mul32uhilo x y) -> (MULTU x y)
+(Mul32uhilo ...) -> (MULTU ...)
(Div32 x y) -> (Select1 (DIV x y))
(Div32u x y) -> (Select1 (DIVU x y))
(Div16u x y) -> (Select1 (DIVU (ZeroExt16to32 x) (ZeroExt16to32 y)))
(Div8 x y) -> (Select1 (DIV (SignExt8to32 x) (SignExt8to32 y)))
(Div8u x y) -> (Select1 (DIVU (ZeroExt8to32 x) (ZeroExt8to32 y)))
-(Div(32|64)F x y) -> (DIV(F|D) x y)
+(Div(32|64)F ...) -> (DIV(F|D) ...)
(Mod32 x y) -> (Select0 (DIV x y))
(Mod32u x y) -> (Select0 (DIVU x y))
// (x + y) / 2 with x>=y -> (x - y) / 2 + y
(Avg32u <t> x y) -> (ADD (SRLconst <t> (SUB <t> x y) [1]) y)
-(And(32|16|8) x y) -> (AND x y)
-(Or(32|16|8) x y) -> (OR x y)
-(Xor(32|16|8) x y) -> (XOR x y)
+(And(32|16|8) ...) -> (AND ...)
+(Or(32|16|8) ...) -> (OR ...)
+(Xor(32|16|8) ...) -> (XOR ...)
// constant shifts
// generic opt rewrites all constant shifts to shift by Const64
(RotateLeft64 <t> x (MOVWconst [c])) -> (Or64 (Lsh64x32 <t> x (MOVWconst [c&63])) (Rsh64Ux32 <t> x (MOVWconst [-c&63])))
// unary ops
-(Neg(32|16|8) x) -> (NEG x)
-(Neg(32|64)F x) -> (NEG(F|D) x)
+(Neg(32|16|8) ...) -> (NEG ...)
+(Neg(32|64)F ...) -> (NEG(F|D) ...)
(Com(32|16|8) x) -> (NORconst [0] x)
-(Sqrt x) -> (SQRTD x)
+(Sqrt ...) -> (SQRTD ...)
// TODO: optimize this case?
-(Ctz32NonZero x) -> (Ctz32 x)
+(Ctz32NonZero ...) -> (Ctz32 ...)
// count trailing zero
// 32 - CLZ(x&-x - 1)
(BitLen32 <t> x) -> (SUB (MOVWconst [32]) (CLZ <t> x))
// boolean ops -- booleans are represented with 0=false, 1=true
-(AndB x y) -> (AND x y)
-(OrB x y) -> (OR x y)
+(AndB ...) -> (AND ...)
+(OrB ...) -> (OR ...)
(EqB x y) -> (XORconst [1] (XOR <typ.Bool> x y))
-(NeqB x y) -> (XOR x y)
+(NeqB ...) -> (XOR ...)
(Not x) -> (XORconst [1] x)
// constants
-(Const(32|16|8) [val]) -> (MOVWconst [val])
-(Const(32|64)F [val]) -> (MOV(F|D)const [val])
+(Const(32|16|8) ...) -> (MOVWconst ...)
+(Const(32|64)F ...) -> (MOV(F|D)const ...)
(ConstNil) -> (MOVWconst [0])
-(ConstBool [b]) -> (MOVWconst [b])
+(ConstBool ...) -> (MOVWconst ...)
// truncations
// 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 ...)
// Zero-/Sign-extensions
-(ZeroExt8to16 x) -> (MOVBUreg x)
-(ZeroExt8to32 x) -> (MOVBUreg x)
-(ZeroExt16to32 x) -> (MOVHUreg x)
+(ZeroExt8to16 ...) -> (MOVBUreg ...)
+(ZeroExt8to32 ...) -> (MOVBUreg ...)
+(ZeroExt16to32 ...) -> (MOVHUreg ...)
-(SignExt8to16 x) -> (MOVBreg x)
-(SignExt8to32 x) -> (MOVBreg x)
-(SignExt16to32 x) -> (MOVHreg x)
+(SignExt8to16 ...) -> (MOVBreg ...)
+(SignExt8to32 ...) -> (MOVBreg ...)
+(SignExt16to32 ...) -> (MOVHreg ...)
(Signmask x) -> (SRAconst x [31])
(Zeromask x) -> (NEG (SGTU x (MOVWconst [0])))
(Slicemask <t> x) -> (SRAconst (NEG <t> x) [31])
// float <-> int conversion
-(Cvt32to(32|64)F x) -> (MOVW(F|D) x)
-(Cvt(32|64)Fto32 x) -> (TRUNC(F|D)W x)
-(Cvt32Fto64F x) -> (MOVFD x)
-(Cvt64Fto32F x) -> (MOVDF x)
+(Cvt32to(32|64)F ...) -> (MOVW(F|D) ...)
+(Cvt(32|64)Fto32 ...) -> (TRUNC(F|D)W ...)
+(Cvt32Fto64F ...) -> (MOVFD ...)
+(Cvt64Fto32F ...) -> (MOVDF ...)
-(Round(32|64)F x) -> x
+(Round(32|64)F ...) -> (Copy ...)
// comparisons
(Eq8 x y) -> (SGTUconst [1] (XOR (ZeroExt8to32 x) (ZeroExt8to32 y)))
(Greater8 x y) -> (SGT (SignExt8to32 x) (SignExt8to32 y))
(Greater16 x y) -> (SGT (SignExt16to32 x) (SignExt16to32 y))
-(Greater32 x y) -> (SGT x y)
+(Greater32 ...) -> (SGT ...)
(Greater(32|64)F x y) -> (FPFlagTrue (CMPGT(F|D) x y))
(Greater8U x y) -> (SGTU (ZeroExt8to32 x) (ZeroExt8to32 y))
(Greater16U x y) -> (SGTU (ZeroExt16to32 x) (ZeroExt16to32 y))
-(Greater32U x y) -> (SGTU x y)
+(Greater32U ...) -> (SGTU ...)
(Geq8 x y) -> (XORconst [1] (SGT (SignExt8to32 y) (SignExt8to32 x)))
(Geq16 x y) -> (XORconst [1] (SGT (SignExt16to32 y) (SignExt16to32 x)))
(OffPtr [off] ptr:(SP)) -> (MOVWaddr [off] ptr)
(OffPtr [off] ptr) -> (ADDconst [off] ptr)
-(Addr {sym} base) -> (MOVWaddr {sym} base)
+(Addr ...) -> (MOVWaddr ...)
(LocalAddr {sym} base _) -> (MOVWaddr {sym} base)
// loads
mem)
// 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 ...)
// atomic intrinsics
-(AtomicLoad(8|32) ptr mem) -> (LoweredAtomicLoad(8|32) ptr mem)
-(AtomicLoadPtr ptr mem) -> (LoweredAtomicLoad32 ptr mem)
+(AtomicLoad(8|32) ...) -> (LoweredAtomicLoad(8|32) ...)
+(AtomicLoadPtr ...) -> (LoweredAtomicLoad32 ...)
-(AtomicStore(8|32) ptr val mem) -> (LoweredAtomicStore(8|32) ptr val mem)
-(AtomicStorePtrNoWB ptr val mem) -> (LoweredAtomicStore32 ptr val mem)
+(AtomicStore(8|32) ...) -> (LoweredAtomicStore(8|32) ...)
+(AtomicStorePtrNoWB ...) -> (LoweredAtomicStore32 ...)
-(AtomicExchange32 ptr val mem) -> (LoweredAtomicExchange ptr val mem)
-(AtomicAdd32 ptr val mem) -> (LoweredAtomicAdd ptr val mem)
+(AtomicExchange32 ...) -> (LoweredAtomicExchange ...)
+(AtomicAdd32 ...) -> (LoweredAtomicAdd ...)
-(AtomicCompareAndSwap32 ptr old new_ mem) -> (LoweredAtomicCas ptr old new_ mem)
+(AtomicCompareAndSwap32 ...) -> (LoweredAtomicCas ...)
// AtomicOr8(ptr,val) -> LoweredAtomicOr(ptr&^3,uint32(val) << ((ptr & 3) * 8))
(AtomicOr8 ptr val mem) && !config.BigEndian ->
// checks
-(NilCheck ptr mem) -> (LoweredNilCheck ptr mem)
+(NilCheck ...) -> (LoweredNilCheck ...)
(IsNonNil ptr) -> (SGTU ptr (MOVWconst [0]))
(IsInBounds idx len) -> (SGTU len idx)
(IsSliceInBounds idx len) -> (XORconst [1] (SGTU idx len))
// pseudo-ops
-(GetClosurePtr) -> (LoweredGetClosurePtr)
-(GetCallerSP) -> (LoweredGetCallerSP)
-(GetCallerPC) -> (LoweredGetCallerPC)
+(GetClosurePtr ...) -> (LoweredGetClosurePtr ...)
+(GetCallerSP ...) -> (LoweredGetCallerSP ...)
+(GetCallerPC ...) -> (LoweredGetCallerPC ...)
(If cond yes no) -> (NE 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)
func rewriteValueMIPS(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueMIPS_OpAdd16(v)
+ v.Op = OpMIPSADD
+ return true
case OpAdd32:
- return rewriteValueMIPS_OpAdd32(v)
+ v.Op = OpMIPSADD
+ return true
case OpAdd32F:
- return rewriteValueMIPS_OpAdd32F(v)
+ v.Op = OpMIPSADDF
+ return true
case OpAdd32withcarry:
return rewriteValueMIPS_OpAdd32withcarry(v)
case OpAdd64F:
- return rewriteValueMIPS_OpAdd64F(v)
+ v.Op = OpMIPSADDD
+ return true
case OpAdd8:
- return rewriteValueMIPS_OpAdd8(v)
+ v.Op = OpMIPSADD
+ return true
case OpAddPtr:
- return rewriteValueMIPS_OpAddPtr(v)
+ v.Op = OpMIPSADD
+ return true
case OpAddr:
- return rewriteValueMIPS_OpAddr(v)
+ v.Op = OpMIPSMOVWaddr
+ return true
case OpAnd16:
- return rewriteValueMIPS_OpAnd16(v)
+ v.Op = OpMIPSAND
+ return true
case OpAnd32:
- return rewriteValueMIPS_OpAnd32(v)
+ v.Op = OpMIPSAND
+ return true
case OpAnd8:
- return rewriteValueMIPS_OpAnd8(v)
+ v.Op = OpMIPSAND
+ return true
case OpAndB:
- return rewriteValueMIPS_OpAndB(v)
+ v.Op = OpMIPSAND
+ return true
case OpAtomicAdd32:
- return rewriteValueMIPS_OpAtomicAdd32(v)
+ v.Op = OpMIPSLoweredAtomicAdd
+ return true
case OpAtomicAnd8:
return rewriteValueMIPS_OpAtomicAnd8(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueMIPS_OpAtomicCompareAndSwap32(v)
+ v.Op = OpMIPSLoweredAtomicCas
+ return true
case OpAtomicExchange32:
- return rewriteValueMIPS_OpAtomicExchange32(v)
+ v.Op = OpMIPSLoweredAtomicExchange
+ return true
case OpAtomicLoad32:
- return rewriteValueMIPS_OpAtomicLoad32(v)
+ v.Op = OpMIPSLoweredAtomicLoad32
+ return true
case OpAtomicLoad8:
- return rewriteValueMIPS_OpAtomicLoad8(v)
+ v.Op = OpMIPSLoweredAtomicLoad8
+ return true
case OpAtomicLoadPtr:
- return rewriteValueMIPS_OpAtomicLoadPtr(v)
+ v.Op = OpMIPSLoweredAtomicLoad32
+ return true
case OpAtomicOr8:
return rewriteValueMIPS_OpAtomicOr8(v)
case OpAtomicStore32:
- return rewriteValueMIPS_OpAtomicStore32(v)
+ v.Op = OpMIPSLoweredAtomicStore32
+ return true
case OpAtomicStore8:
- return rewriteValueMIPS_OpAtomicStore8(v)
+ v.Op = OpMIPSLoweredAtomicStore8
+ return true
case OpAtomicStorePtrNoWB:
- return rewriteValueMIPS_OpAtomicStorePtrNoWB(v)
+ v.Op = OpMIPSLoweredAtomicStore32
+ return true
case OpAvg32u:
return rewriteValueMIPS_OpAvg32u(v)
case OpBitLen32:
return rewriteValueMIPS_OpBitLen32(v)
case OpClosureCall:
- return rewriteValueMIPS_OpClosureCall(v)
+ v.Op = OpMIPSCALLclosure
+ return true
case OpCom16:
return rewriteValueMIPS_OpCom16(v)
case OpCom32:
case OpCom8:
return rewriteValueMIPS_OpCom8(v)
case OpConst16:
- return rewriteValueMIPS_OpConst16(v)
+ v.Op = OpMIPSMOVWconst
+ return true
case OpConst32:
- return rewriteValueMIPS_OpConst32(v)
+ v.Op = OpMIPSMOVWconst
+ return true
case OpConst32F:
- return rewriteValueMIPS_OpConst32F(v)
+ v.Op = OpMIPSMOVFconst
+ return true
case OpConst64F:
- return rewriteValueMIPS_OpConst64F(v)
+ v.Op = OpMIPSMOVDconst
+ return true
case OpConst8:
- return rewriteValueMIPS_OpConst8(v)
+ v.Op = OpMIPSMOVWconst
+ return true
case OpConstBool:
- return rewriteValueMIPS_OpConstBool(v)
+ v.Op = OpMIPSMOVWconst
+ return true
case OpConstNil:
return rewriteValueMIPS_OpConstNil(v)
case OpCtz32:
return rewriteValueMIPS_OpCtz32(v)
case OpCtz32NonZero:
- return rewriteValueMIPS_OpCtz32NonZero(v)
+ v.Op = OpCtz32
+ return true
case OpCvt32Fto32:
- return rewriteValueMIPS_OpCvt32Fto32(v)
+ v.Op = OpMIPSTRUNCFW
+ return true
case OpCvt32Fto64F:
- return rewriteValueMIPS_OpCvt32Fto64F(v)
+ v.Op = OpMIPSMOVFD
+ return true
case OpCvt32to32F:
- return rewriteValueMIPS_OpCvt32to32F(v)
+ v.Op = OpMIPSMOVWF
+ return true
case OpCvt32to64F:
- return rewriteValueMIPS_OpCvt32to64F(v)
+ v.Op = OpMIPSMOVWD
+ return true
case OpCvt64Fto32:
- return rewriteValueMIPS_OpCvt64Fto32(v)
+ v.Op = OpMIPSTRUNCDW
+ return true
case OpCvt64Fto32F:
- return rewriteValueMIPS_OpCvt64Fto32F(v)
+ v.Op = OpMIPSMOVDF
+ return true
case OpDiv16:
return rewriteValueMIPS_OpDiv16(v)
case OpDiv16u:
case OpDiv32:
return rewriteValueMIPS_OpDiv32(v)
case OpDiv32F:
- return rewriteValueMIPS_OpDiv32F(v)
+ v.Op = OpMIPSDIVF
+ return true
case OpDiv32u:
return rewriteValueMIPS_OpDiv32u(v)
case OpDiv64F:
- return rewriteValueMIPS_OpDiv64F(v)
+ v.Op = OpMIPSDIVD
+ return true
case OpDiv8:
return rewriteValueMIPS_OpDiv8(v)
case OpDiv8u:
case OpGeq8U:
return rewriteValueMIPS_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValueMIPS_OpGetCallerPC(v)
+ v.Op = OpMIPSLoweredGetCallerPC
+ return true
case OpGetCallerSP:
- return rewriteValueMIPS_OpGetCallerSP(v)
+ v.Op = OpMIPSLoweredGetCallerSP
+ return true
case OpGetClosurePtr:
- return rewriteValueMIPS_OpGetClosurePtr(v)
+ v.Op = OpMIPSLoweredGetClosurePtr
+ return true
case OpGreater16:
return rewriteValueMIPS_OpGreater16(v)
case OpGreater16U:
return rewriteValueMIPS_OpGreater16U(v)
case OpGreater32:
- return rewriteValueMIPS_OpGreater32(v)
+ v.Op = OpMIPSSGT
+ return true
case OpGreater32F:
return rewriteValueMIPS_OpGreater32F(v)
case OpGreater32U:
- return rewriteValueMIPS_OpGreater32U(v)
+ v.Op = OpMIPSSGTU
+ return true
case OpGreater64F:
return rewriteValueMIPS_OpGreater64F(v)
case OpGreater8:
case OpHmul32u:
return rewriteValueMIPS_OpHmul32u(v)
case OpInterCall:
- return rewriteValueMIPS_OpInterCall(v)
+ v.Op = OpMIPSCALLinter
+ return true
case OpIsInBounds:
return rewriteValueMIPS_OpIsInBounds(v)
case OpIsNonNil:
case OpMove:
return rewriteValueMIPS_OpMove(v)
case OpMul16:
- return rewriteValueMIPS_OpMul16(v)
+ v.Op = OpMIPSMUL
+ return true
case OpMul32:
- return rewriteValueMIPS_OpMul32(v)
+ v.Op = OpMIPSMUL
+ return true
case OpMul32F:
- return rewriteValueMIPS_OpMul32F(v)
+ v.Op = OpMIPSMULF
+ return true
case OpMul32uhilo:
- return rewriteValueMIPS_OpMul32uhilo(v)
+ v.Op = OpMIPSMULTU
+ return true
case OpMul64F:
- return rewriteValueMIPS_OpMul64F(v)
+ v.Op = OpMIPSMULD
+ return true
case OpMul8:
- return rewriteValueMIPS_OpMul8(v)
+ v.Op = OpMIPSMUL
+ return true
case OpNeg16:
- return rewriteValueMIPS_OpNeg16(v)
+ v.Op = OpMIPSNEG
+ return true
case OpNeg32:
- return rewriteValueMIPS_OpNeg32(v)
+ v.Op = OpMIPSNEG
+ return true
case OpNeg32F:
- return rewriteValueMIPS_OpNeg32F(v)
+ v.Op = OpMIPSNEGF
+ return true
case OpNeg64F:
- return rewriteValueMIPS_OpNeg64F(v)
+ v.Op = OpMIPSNEGD
+ return true
case OpNeg8:
- return rewriteValueMIPS_OpNeg8(v)
+ v.Op = OpMIPSNEG
+ return true
case OpNeq16:
return rewriteValueMIPS_OpNeq16(v)
case OpNeq32:
case OpNeq8:
return rewriteValueMIPS_OpNeq8(v)
case OpNeqB:
- return rewriteValueMIPS_OpNeqB(v)
+ v.Op = OpMIPSXOR
+ return true
case OpNeqPtr:
return rewriteValueMIPS_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValueMIPS_OpNilCheck(v)
+ v.Op = OpMIPSLoweredNilCheck
+ return true
case OpNot:
return rewriteValueMIPS_OpNot(v)
case OpOffPtr:
return rewriteValueMIPS_OpOffPtr(v)
case OpOr16:
- return rewriteValueMIPS_OpOr16(v)
+ v.Op = OpMIPSOR
+ return true
case OpOr32:
- return rewriteValueMIPS_OpOr32(v)
+ v.Op = OpMIPSOR
+ return true
case OpOr8:
- return rewriteValueMIPS_OpOr8(v)
+ v.Op = OpMIPSOR
+ return true
case OpOrB:
- return rewriteValueMIPS_OpOrB(v)
+ v.Op = OpMIPSOR
+ return true
case OpPanicBounds:
return rewriteValueMIPS_OpPanicBounds(v)
case OpPanicExtend:
case OpRotateLeft8:
return rewriteValueMIPS_OpRotateLeft8(v)
case OpRound32F:
- return rewriteValueMIPS_OpRound32F(v)
+ v.Op = OpCopy
+ return true
case OpRound64F:
- return rewriteValueMIPS_OpRound64F(v)
+ v.Op = OpCopy
+ return true
case OpRsh16Ux16:
return rewriteValueMIPS_OpRsh16Ux16(v)
case OpRsh16Ux32:
case OpSelect1:
return rewriteValueMIPS_OpSelect1(v)
case OpSignExt16to32:
- return rewriteValueMIPS_OpSignExt16to32(v)
+ v.Op = OpMIPSMOVHreg
+ return true
case OpSignExt8to16:
- return rewriteValueMIPS_OpSignExt8to16(v)
+ v.Op = OpMIPSMOVBreg
+ return true
case OpSignExt8to32:
- return rewriteValueMIPS_OpSignExt8to32(v)
+ v.Op = OpMIPSMOVBreg
+ return true
case OpSignmask:
return rewriteValueMIPS_OpSignmask(v)
case OpSlicemask:
return rewriteValueMIPS_OpSlicemask(v)
case OpSqrt:
- return rewriteValueMIPS_OpSqrt(v)
+ v.Op = OpMIPSSQRTD
+ return true
case OpStaticCall:
- return rewriteValueMIPS_OpStaticCall(v)
+ v.Op = OpMIPSCALLstatic
+ return true
case OpStore:
return rewriteValueMIPS_OpStore(v)
case OpSub16:
- return rewriteValueMIPS_OpSub16(v)
+ v.Op = OpMIPSSUB
+ return true
case OpSub32:
- return rewriteValueMIPS_OpSub32(v)
+ v.Op = OpMIPSSUB
+ return true
case OpSub32F:
- return rewriteValueMIPS_OpSub32F(v)
+ v.Op = OpMIPSSUBF
+ return true
case OpSub32withcarry:
return rewriteValueMIPS_OpSub32withcarry(v)
case OpSub64F:
- return rewriteValueMIPS_OpSub64F(v)
+ v.Op = OpMIPSSUBD
+ return true
case OpSub8:
- return rewriteValueMIPS_OpSub8(v)
+ v.Op = OpMIPSSUB
+ return true
case OpSubPtr:
- return rewriteValueMIPS_OpSubPtr(v)
+ v.Op = OpMIPSSUB
+ return true
case OpTrunc16to8:
- return rewriteValueMIPS_OpTrunc16to8(v)
+ v.Op = OpCopy
+ return true
case OpTrunc32to16:
- return rewriteValueMIPS_OpTrunc32to16(v)
+ v.Op = OpCopy
+ return true
case OpTrunc32to8:
- return rewriteValueMIPS_OpTrunc32to8(v)
+ v.Op = OpCopy
+ return true
case OpWB:
- return rewriteValueMIPS_OpWB(v)
+ v.Op = OpMIPSLoweredWB
+ return true
case OpXor16:
- return rewriteValueMIPS_OpXor16(v)
+ v.Op = OpMIPSXOR
+ return true
case OpXor32:
- return rewriteValueMIPS_OpXor32(v)
+ v.Op = OpMIPSXOR
+ return true
case OpXor8:
- return rewriteValueMIPS_OpXor8(v)
+ v.Op = OpMIPSXOR
+ return true
case OpZero:
return rewriteValueMIPS_OpZero(v)
case OpZeroExt16to32:
- return rewriteValueMIPS_OpZeroExt16to32(v)
+ v.Op = OpMIPSMOVHUreg
+ return true
case OpZeroExt8to16:
- return rewriteValueMIPS_OpZeroExt8to16(v)
+ v.Op = OpMIPSMOVBUreg
+ return true
case OpZeroExt8to32:
- return rewriteValueMIPS_OpZeroExt8to32(v)
+ v.Op = OpMIPSMOVBUreg
+ return true
case OpZeromask:
return rewriteValueMIPS_OpZeromask(v)
}
return false
}
-func rewriteValueMIPS_OpAdd16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Add16 x y)
- // result: (ADD x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSADD)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpAdd32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Add32 x y)
- // result: (ADD x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSADD)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpAdd32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Add32F x y)
- // result: (ADDF x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSADDF)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
return true
}
}
-func rewriteValueMIPS_OpAdd64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Add64F x y)
- // result: (ADDD x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSADDD)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpAdd8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Add8 x y)
- // result: (ADD x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSADD)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpAddPtr(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AddPtr x y)
- // result: (ADD x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSADD)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpAddr(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Addr {sym} base)
- // result: (MOVWaddr {sym} base)
- for {
- sym := v.Aux
- base := v_0
- v.reset(OpMIPSMOVWaddr)
- v.Aux = sym
- v.AddArg(base)
- return true
- }
-}
-func rewriteValueMIPS_OpAnd16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (And16 x y)
- // result: (AND x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSAND)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpAnd32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (And32 x y)
- // result: (AND x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSAND)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpAnd8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (And8 x y)
- // result: (AND x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSAND)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpAndB(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AndB x y)
- // result: (AND x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSAND)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AtomicAdd32 ptr val mem)
- // result: (LoweredAtomicAdd ptr val mem)
- for {
- ptr := v_0
- val := v_1
- mem := v_2
- v.reset(OpMIPSLoweredAtomicAdd)
- v.AddArg(ptr)
- v.AddArg(val)
- v.AddArg(mem)
- return true
- }
-}
func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
}
return false
}
-func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool {
- v_3 := v.Args[3]
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AtomicCompareAndSwap32 ptr old new_ mem)
- // result: (LoweredAtomicCas ptr old new_ mem)
- for {
- ptr := v_0
- old := v_1
- new_ := v_2
- mem := v_3
- v.reset(OpMIPSLoweredAtomicCas)
- v.AddArg(ptr)
- v.AddArg(old)
- v.AddArg(new_)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AtomicExchange32 ptr val mem)
- // result: (LoweredAtomicExchange ptr val mem)
- for {
- ptr := v_0
- val := v_1
- mem := v_2
- v.reset(OpMIPSLoweredAtomicExchange)
- v.AddArg(ptr)
- v.AddArg(val)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AtomicLoad32 ptr mem)
- // result: (LoweredAtomicLoad32 ptr mem)
- for {
- ptr := v_0
- mem := v_1
- v.reset(OpMIPSLoweredAtomicLoad32)
- v.AddArg(ptr)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueMIPS_OpAtomicLoad8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AtomicLoad8 ptr mem)
- // result: (LoweredAtomicLoad8 ptr mem)
- for {
- ptr := v_0
- mem := v_1
- v.reset(OpMIPSLoweredAtomicLoad8)
- v.AddArg(ptr)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AtomicLoadPtr ptr mem)
- // result: (LoweredAtomicLoad32 ptr mem)
- for {
- ptr := v_0
- mem := v_1
- v.reset(OpMIPSLoweredAtomicLoad32)
- v.AddArg(ptr)
- v.AddArg(mem)
- return true
- }
-}
func rewriteValueMIPS_OpAtomicOr8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
}
return false
}
-func rewriteValueMIPS_OpAtomicStore32(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AtomicStore32 ptr val mem)
- // result: (LoweredAtomicStore32 ptr val mem)
- for {
- ptr := v_0
- val := v_1
- mem := v_2
- v.reset(OpMIPSLoweredAtomicStore32)
- v.AddArg(ptr)
- v.AddArg(val)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueMIPS_OpAtomicStore8(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AtomicStore8 ptr val mem)
- // result: (LoweredAtomicStore8 ptr val mem)
- for {
- ptr := v_0
- val := v_1
- mem := v_2
- v.reset(OpMIPSLoweredAtomicStore8)
- v.AddArg(ptr)
- v.AddArg(val)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (AtomicStorePtrNoWB ptr val mem)
- // result: (LoweredAtomicStore32 ptr val mem)
- for {
- ptr := v_0
- val := v_1
- mem := v_2
- v.reset(OpMIPSLoweredAtomicStore32)
- v.AddArg(ptr)
- v.AddArg(val)
- v.AddArg(mem)
- return true
- }
-}
func rewriteValueMIPS_OpAvg32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueMIPS_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(OpMIPSCALLclosure)
- v.AuxInt = argwid
- v.AddArg(entry)
- v.AddArg(closure)
- v.AddArg(mem)
- return true
- }
-}
func rewriteValueMIPS_OpCom16(v *Value) bool {
v_0 := v.Args[0]
// match: (Com16 x)
return true
}
}
-func rewriteValueMIPS_OpConst16(v *Value) bool {
- // match: (Const16 [val])
- // result: (MOVWconst [val])
- for {
- val := v.AuxInt
- v.reset(OpMIPSMOVWconst)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueMIPS_OpConst32(v *Value) bool {
- // match: (Const32 [val])
- // result: (MOVWconst [val])
- for {
- val := v.AuxInt
- v.reset(OpMIPSMOVWconst)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueMIPS_OpConst32F(v *Value) bool {
- // match: (Const32F [val])
- // result: (MOVFconst [val])
- for {
- val := v.AuxInt
- v.reset(OpMIPSMOVFconst)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueMIPS_OpConst64F(v *Value) bool {
- // match: (Const64F [val])
- // result: (MOVDconst [val])
- for {
- val := v.AuxInt
- v.reset(OpMIPSMOVDconst)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueMIPS_OpConst8(v *Value) bool {
- // match: (Const8 [val])
- // result: (MOVWconst [val])
- for {
- val := v.AuxInt
- v.reset(OpMIPSMOVWconst)
- v.AuxInt = val
- return true
- }
-}
-func rewriteValueMIPS_OpConstBool(v *Value) bool {
- // match: (ConstBool [b])
- // result: (MOVWconst [b])
- for {
- b := v.AuxInt
- v.reset(OpMIPSMOVWconst)
- v.AuxInt = b
- return true
- }
-}
func rewriteValueMIPS_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (MOVWconst [0])
for {
t := v.Type
x := v_0
- v.reset(OpMIPSSUB)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, typ.UInt32)
- v0.AuxInt = 32
- v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSCLZ, t)
- v2 := b.NewValue0(v.Pos, OpMIPSSUBconst, t)
- v2.AuxInt = 1
- v3 := b.NewValue0(v.Pos, OpMIPSAND, t)
- v3.AddArg(x)
- v4 := b.NewValue0(v.Pos, OpMIPSNEG, t)
- v4.AddArg(x)
- v3.AddArg(v4)
- v2.AddArg(v3)
- v1.AddArg(v2)
- v.AddArg(v1)
- return true
- }
-}
-func rewriteValueMIPS_OpCtz32NonZero(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Ctz32NonZero x)
- // result: (Ctz32 x)
- for {
- x := v_0
- v.reset(OpCtz32)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt32Fto32 x)
- // result: (TRUNCFW x)
- for {
- x := v_0
- v.reset(OpMIPSTRUNCFW)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt32Fto64F x)
- // result: (MOVFD x)
- for {
- x := v_0
- v.reset(OpMIPSMOVFD)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpCvt32to32F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt32to32F x)
- // result: (MOVWF x)
- for {
- x := v_0
- v.reset(OpMIPSMOVWF)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpCvt32to64F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt32to64F x)
- // result: (MOVWD x)
- for {
- x := v_0
- v.reset(OpMIPSMOVWD)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt64Fto32 x)
- // result: (TRUNCDW x)
- for {
- x := v_0
- v.reset(OpMIPSTRUNCDW)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Cvt64Fto32F x)
- // result: (MOVDF x)
- for {
- x := v_0
- v.reset(OpMIPSMOVDF)
- v.AddArg(x)
+ v.reset(OpMIPSSUB)
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, typ.UInt32)
+ v0.AuxInt = 32
+ v.AddArg(v0)
+ v1 := b.NewValue0(v.Pos, OpMIPSCLZ, t)
+ v2 := b.NewValue0(v.Pos, OpMIPSSUBconst, t)
+ v2.AuxInt = 1
+ v3 := b.NewValue0(v.Pos, OpMIPSAND, t)
+ v3.AddArg(x)
+ v4 := b.NewValue0(v.Pos, OpMIPSNEG, t)
+ v4.AddArg(x)
+ v3.AddArg(v4)
+ v2.AddArg(v3)
+ v1.AddArg(v2)
+ v.AddArg(v1)
return true
}
}
return true
}
}
-func rewriteValueMIPS_OpDiv32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Div32F x y)
- // result: (DIVF x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSDIVF)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueMIPS_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueMIPS_OpDiv64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Div64F x y)
- // result: (DIVD x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSDIVD)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueMIPS_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueMIPS_OpGetCallerPC(v *Value) bool {
- // match: (GetCallerPC)
- // result: (LoweredGetCallerPC)
- for {
- v.reset(OpMIPSLoweredGetCallerPC)
- return true
- }
-}
-func rewriteValueMIPS_OpGetCallerSP(v *Value) bool {
- // match: (GetCallerSP)
- // result: (LoweredGetCallerSP)
- for {
- v.reset(OpMIPSLoweredGetCallerSP)
- return true
- }
-}
-func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool {
- // match: (GetClosurePtr)
- // result: (LoweredGetClosurePtr)
- for {
- v.reset(OpMIPSLoweredGetClosurePtr)
- return true
- }
-}
func rewriteValueMIPS_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueMIPS_OpGreater32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater32 x y)
- // result: (SGT x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSSGT)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueMIPS_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueMIPS_OpGreater32U(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Greater32U x y)
- // result: (SGTU x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSSGTU)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueMIPS_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueMIPS_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(OpMIPSCALLinter)
- v.AuxInt = argwid
- v.AddArg(entry)
- v.AddArg(mem)
- return true
- }
-}
func rewriteValueMIPS_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
}
return false
}
-func rewriteValueMIPS_OpMul16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul16 x y)
- // result: (MUL x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSMUL)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpMul32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul32 x y)
- // result: (MUL x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSMUL)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpMul32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul32F x y)
- // result: (MULF x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSMULF)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpMul32uhilo(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul32uhilo x y)
- // result: (MULTU x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSMULTU)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpMul64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul64F x y)
- // result: (MULD x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSMULD)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpMul8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Mul8 x y)
- // result: (MUL x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSMUL)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpNeg16(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Neg16 x)
- // result: (NEG x)
- for {
- x := v_0
- v.reset(OpMIPSNEG)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpNeg32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Neg32 x)
- // result: (NEG x)
- for {
- x := v_0
- v.reset(OpMIPSNEG)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpNeg32F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Neg32F x)
- // result: (NEGF x)
- for {
- x := v_0
- v.reset(OpMIPSNEGF)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpNeg64F(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Neg64F x)
- // result: (NEGD x)
- for {
- x := v_0
- v.reset(OpMIPSNEGD)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpNeg8(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Neg8 x)
- // result: (NEG x)
- for {
- x := v_0
- v.reset(OpMIPSNEG)
- v.AddArg(x)
- return true
- }
-}
func rewriteValueMIPS_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueMIPS_OpNeqB(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (NeqB x y)
- // result: (XOR x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSXOR)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueMIPS_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
return true
}
}
-func rewriteValueMIPS_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(OpMIPSLoweredNilCheck)
- v.AddArg(ptr)
- v.AddArg(mem)
- return true
- }
-}
func rewriteValueMIPS_OpNot(v *Value) bool {
v_0 := v.Args[0]
- // match: (Not x)
- // result: (XORconst [1] x)
- for {
- x := v_0
- v.reset(OpMIPSXORconst)
- v.AuxInt = 1
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpOffPtr(v *Value) bool {
- v_0 := v.Args[0]
- // match: (OffPtr [off] ptr:(SP))
- // result: (MOVWaddr [off] ptr)
- for {
- off := v.AuxInt
- ptr := v_0
- if ptr.Op != OpSP {
- break
- }
- v.reset(OpMIPSMOVWaddr)
- v.AuxInt = off
- v.AddArg(ptr)
- return true
- }
- // match: (OffPtr [off] ptr)
- // result: (ADDconst [off] ptr)
- for {
- off := v.AuxInt
- ptr := v_0
- v.reset(OpMIPSADDconst)
- v.AuxInt = off
- v.AddArg(ptr)
- return true
- }
-}
-func rewriteValueMIPS_OpOr16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Or16 x y)
- // result: (OR x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSOR)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpOr32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Or32 x y)
- // result: (OR x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSOR)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpOr8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Or8 x y)
- // result: (OR x y)
+ // match: (Not x)
+ // result: (XORconst [1] x)
for {
x := v_0
- y := v_1
- v.reset(OpMIPSOR)
+ v.reset(OpMIPSXORconst)
+ v.AuxInt = 1
v.AddArg(x)
- v.AddArg(y)
return true
}
}
-func rewriteValueMIPS_OpOrB(v *Value) bool {
- v_1 := v.Args[1]
+func rewriteValueMIPS_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
- // match: (OrB x y)
- // result: (OR x y)
+ // match: (OffPtr [off] ptr:(SP))
+ // result: (MOVWaddr [off] ptr)
for {
- x := v_0
- y := v_1
- v.reset(OpMIPSOR)
- v.AddArg(x)
- v.AddArg(y)
+ off := v.AuxInt
+ ptr := v_0
+ if ptr.Op != OpSP {
+ break
+ }
+ v.reset(OpMIPSMOVWaddr)
+ v.AuxInt = off
+ v.AddArg(ptr)
+ return true
+ }
+ // match: (OffPtr [off] ptr)
+ // result: (ADDconst [off] ptr)
+ for {
+ off := v.AuxInt
+ ptr := v_0
+ v.reset(OpMIPSADDconst)
+ v.AuxInt = off
+ v.AddArg(ptr)
return true
}
}
}
return false
}
-func rewriteValueMIPS_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 rewriteValueMIPS_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 rewriteValueMIPS_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
}
return false
}
-func rewriteValueMIPS_OpSignExt16to32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (SignExt16to32 x)
- // result: (MOVHreg x)
- for {
- x := v_0
- v.reset(OpMIPSMOVHreg)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpSignExt8to16(v *Value) bool {
- v_0 := v.Args[0]
- // match: (SignExt8to16 x)
- // result: (MOVBreg x)
- for {
- x := v_0
- v.reset(OpMIPSMOVBreg)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpSignExt8to32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (SignExt8to32 x)
- // result: (MOVBreg x)
- for {
- x := v_0
- v.reset(OpMIPSMOVBreg)
- v.AddArg(x)
- return true
- }
-}
func rewriteValueMIPS_OpSignmask(v *Value) bool {
v_0 := v.Args[0]
// match: (Signmask x)
return true
}
}
-func rewriteValueMIPS_OpSqrt(v *Value) bool {
- v_0 := v.Args[0]
- // match: (Sqrt x)
- // result: (SQRTD x)
- for {
- x := v_0
- v.reset(OpMIPSSQRTD)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_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(OpMIPSCALLstatic)
- v.AuxInt = argwid
- v.Aux = target
- v.AddArg(mem)
- return true
- }
-}
func rewriteValueMIPS_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
}
return false
}
-func rewriteValueMIPS_OpSub16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub16 x y)
- // result: (SUB x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSSUB)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpSub32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub32 x y)
- // result: (SUB x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSSUB)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpSub32F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub32F x y)
- // result: (SUBF x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSSUBF)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueMIPS_OpSub32withcarry(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
return true
}
}
-func rewriteValueMIPS_OpSub64F(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub64F x y)
- // result: (SUBD x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSSUBD)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpSub8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Sub8 x y)
- // result: (SUB x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSSUB)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpSubPtr(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (SubPtr x y)
- // result: (SUB x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSSUB)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_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 rewriteValueMIPS_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 rewriteValueMIPS_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 rewriteValueMIPS_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(OpMIPSLoweredWB)
- v.Aux = fn
- v.AddArg(destptr)
- v.AddArg(srcptr)
- v.AddArg(mem)
- return true
- }
-}
-func rewriteValueMIPS_OpXor16(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Xor16 x y)
- // result: (XOR x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSXOR)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpXor32(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Xor32 x y)
- // result: (XOR x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSXOR)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
-func rewriteValueMIPS_OpXor8(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- // match: (Xor8 x y)
- // result: (XOR x y)
- for {
- x := v_0
- y := v_1
- v.reset(OpMIPSXOR)
- v.AddArg(x)
- v.AddArg(y)
- return true
- }
-}
func rewriteValueMIPS_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
}
return false
}
-func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (ZeroExt16to32 x)
- // result: (MOVHUreg x)
- for {
- x := v_0
- v.reset(OpMIPSMOVHUreg)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool {
- v_0 := v.Args[0]
- // match: (ZeroExt8to16 x)
- // result: (MOVBUreg x)
- for {
- x := v_0
- v.reset(OpMIPSMOVBUreg)
- v.AddArg(x)
- return true
- }
-}
-func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool {
- v_0 := v.Args[0]
- // match: (ZeroExt8to32 x)
- // result: (MOVBUreg x)
- for {
- x := v_0
- v.reset(OpMIPSMOVBUreg)
- v.AddArg(x)
- return true
- }
-}
func rewriteValueMIPS_OpZeromask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block