diff options
| author | Josh Bleecher Snyder <josharian@gmail.com> | 2017-03-17 10:50:20 -0700 |
|---|---|---|
| committer | Josh Bleecher Snyder <josharian@gmail.com> | 2017-03-17 22:35:29 +0000 |
| commit | 193510f2f6a0d01bb03595ba12dd2b05109980e3 (patch) | |
| tree | fd81d434a61d0d19a7612a0d40aafd7c8cfbd8fe | |
| parent | 09272ae981905dcdc76ab7ffbda996c49d86595c (diff) | |
| download | go-git-193510f2f6a0d01bb03595ba12dd2b05109980e3.tar.gz | |
cmd/compile: evaluate config as needed in rewrite rules
Prior to this CL, config was an explicit argument
to the SSA rewrite rules, and rules that needed
a Frontend got at it via config.
An upcoming CL moves Frontend from Config to Func,
so rules can no longer reach Frontend via Config.
Passing a Frontend as an argument to the rewrite rules
causes a 2-3% regression in compile times.
This CL takes a different approach:
It treats the variable names "config" and "fe"
as special and calculates them as needed.
The "as needed part" is also important to performance:
If they are calculated eagerly, the nilchecks themselves
cause a regression.
This introduces a little bit of magic into the rewrite
generator. However, from the perspective of the rules,
the config variable was already more or less magic.
And it makes the upcoming changes much clearer.
Passes toolstash -cmp.
Change-Id: I173f2bcc124cba43d53138bfa3775e21316a9107
Reviewed-on: https://go-review.googlesource.com/38326
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
25 files changed, 11847 insertions, 11995 deletions
diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 30ee9b45ff..8842db01bd 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -15,31 +15,36 @@ import ( // It is created once, early during compilation, // and shared across all compilations. type Config struct { - arch string // "amd64", etc. - IntSize int64 // 4 or 8 - PtrSize int64 // 4 or 8 - RegSize int64 // 4 or 8 - lowerBlock func(*Block, *Config) bool // lowering function - lowerValue func(*Value, *Config) bool // lowering function - registers []Register // machine registers - gpRegMask regMask // general purpose integer register mask - fpRegMask regMask // floating point register mask - specialRegMask regMask // special register mask - FPReg int8 // register number of frame pointer, -1 if not used - LinkReg int8 // register number of link register if it is a general purpose register, -1 if not used - hasGReg bool // has hardware g register - fe Frontend // callbacks into compiler frontend - ctxt *obj.Link // Generic arch information - optimize bool // Do optimization - noDuffDevice bool // Don't use Duff's device - nacl bool // GOOS=nacl - use387 bool // GO386=387 - OldArch bool // True for older versions of architecture, e.g. true for PPC64BE, false for PPC64LE - NeedsFpScratch bool // No direct move between GP and FP register sets - BigEndian bool // - sparsePhiCutoff uint64 // Sparse phi location algorithm used above this #blocks*#variables score + arch string // "amd64", etc. + IntSize int64 // 4 or 8 + PtrSize int64 // 4 or 8 + RegSize int64 // 4 or 8 + lowerBlock blockRewriter // lowering function + lowerValue valueRewriter // lowering function + registers []Register // machine registers + gpRegMask regMask // general purpose integer register mask + fpRegMask regMask // floating point register mask + specialRegMask regMask // special register mask + FPReg int8 // register number of frame pointer, -1 if not used + LinkReg int8 // register number of link register if it is a general purpose register, -1 if not used + hasGReg bool // has hardware g register + fe Frontend // callbacks into compiler frontend + ctxt *obj.Link // Generic arch information + optimize bool // Do optimization + noDuffDevice bool // Don't use Duff's device + nacl bool // GOOS=nacl + use387 bool // GO386=387 + OldArch bool // True for older versions of architecture, e.g. true for PPC64BE, false for PPC64LE + NeedsFpScratch bool // No direct move between GP and FP register sets + BigEndian bool // + sparsePhiCutoff uint64 // Sparse phi location algorithm used above this #blocks*#variables score } +type ( + blockRewriter func(*Block) bool + valueRewriter func(*Value) bool +) + type TypeSource interface { TypeBool() Type TypeInt8() Type diff --git a/src/cmd/compile/internal/ssa/gen/386.rules b/src/cmd/compile/internal/ssa/gen/386.rules index 2c3cbfcfd9..4eb7720fd3 100644 --- a/src/cmd/compile/internal/ssa/gen/386.rules +++ b/src/cmd/compile/internal/ssa/gen/386.rules @@ -68,8 +68,8 @@ (Neg32 x) -> (NEGL x) (Neg16 x) -> (NEGL x) (Neg8 x) -> (NEGL x) -(Neg32F x) && !config.use387 -> (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> [f2i(math.Copysign(0, -1))])) -(Neg64F x) && !config.use387 -> (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> [f2i(math.Copysign(0, -1))])) +(Neg32F x) && !config.use387 -> (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))])) +(Neg64F x) && !config.use387 -> (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))])) (Neg32F x) && config.use387 -> (FCHS x) (Neg64F x) && config.use387 -> (FCHS x) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index e68a7783f5..9f45154ad3 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -78,8 +78,8 @@ (Neg32 x) -> (NEGL x) (Neg16 x) -> (NEGL x) (Neg8 x) -> (NEGL x) -(Neg32F x) -> (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> [f2i(math.Copysign(0, -1))])) -(Neg64F x) -> (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> [f2i(math.Copysign(0, -1))])) +(Neg32F x) -> (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))])) +(Neg64F x) -> (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))])) (Com64 x) -> (NOTQ x) (Com32 x) -> (NOTL x) @@ -98,10 +98,10 @@ // Lowering other arithmetic (Ctz64 <t> x) -> (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <TypeFlags> (BSFQ x))) -(Ctz32 x) -> (Select0 (BSFQ (ORQ <config.Frontend().TypeUInt64()> (MOVQconst [1<<32]) x))) +(Ctz32 x) -> (Select0 (BSFQ (ORQ <fe.TypeUInt64()> (MOVQconst [1<<32]) x))) (BitLen64 <t> x) -> (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <TypeFlags> (BSRQ x)))) -(BitLen32 x) -> (BitLen64 (MOVLQZX <config.Frontend().TypeUInt64()> x)) +(BitLen32 x) -> (BitLen64 (MOVLQZX <fe.TypeUInt64()> x)) (Bswap64 x) -> (BSWAPQ x) (Bswap32 x) -> (BSWAPL x) @@ -472,10 +472,10 @@ // Atomic stores. We use XCHG to prevent the hardware reordering a subsequent load. // TODO: most runtime uses of atomic stores don't need that property. Use normal stores for those? -(AtomicStore32 ptr val mem) -> (Select1 (XCHGL <MakeTuple(config.Frontend().TypeUInt32(),TypeMem)> val ptr mem)) -(AtomicStore64 ptr val mem) -> (Select1 (XCHGQ <MakeTuple(config.Frontend().TypeUInt64(),TypeMem)> val ptr mem)) -(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 8 -> (Select1 (XCHGQ <MakeTuple(config.Frontend().TypeBytePtr(),TypeMem)> val ptr mem)) -(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 4 -> (Select1 (XCHGL <MakeTuple(config.Frontend().TypeBytePtr(),TypeMem)> val ptr mem)) +(AtomicStore32 ptr val mem) -> (Select1 (XCHGL <MakeTuple(fe.TypeUInt32(),TypeMem)> val ptr mem)) +(AtomicStore64 ptr val mem) -> (Select1 (XCHGQ <MakeTuple(fe.TypeUInt64(),TypeMem)> val ptr mem)) +(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 8 -> (Select1 (XCHGQ <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem)) +(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 4 -> (Select1 (XCHGL <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem)) // Atomic exchanges. (AtomicExchange32 ptr val mem) -> (XCHGL val ptr mem) @@ -553,8 +553,8 @@ (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no) -> (NEF cmp yes no) // Disabled because it interferes with the pattern match above and makes worse code. -// (SETNEF x) -> (ORQ (SETNE <config.Frontend().TypeInt8()> x) (SETNAN <config.Frontend().TypeInt8()> x)) -// (SETEQF x) -> (ANDQ (SETEQ <config.Frontend().TypeInt8()> x) (SETORD <config.Frontend().TypeInt8()> x)) +// (SETNEF x) -> (ORQ (SETNE <fe.TypeInt8()> x) (SETNAN <fe.TypeInt8()> x)) +// (SETEQF x) -> (ANDQ (SETEQ <fe.TypeInt8()> x) (SETORD <fe.TypeInt8()> x)) // fold constants into instructions (ADDQ x (MOVQconst [c])) && is32Bit(c) -> (ADDQconst [c] x) diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules index 9413bd4d31..4d37f63989 100644 --- a/src/cmd/compile/internal/ssa/gen/ARM.rules +++ b/src/cmd/compile/internal/ssa/gen/ARM.rules @@ -34,12 +34,12 @@ (Mul32uhilo x y) -> (MULLU x y) (Div32 x y) -> - (SUB (XOR <config.fe.TypeUInt32()> // negate the result if one operand is negative - (Select0 <config.fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} - (SUB <config.fe.TypeUInt32()> (XOR x <config.fe.TypeUInt32()> (Signmask x)) (Signmask x)) // negate x if negative - (SUB <config.fe.TypeUInt32()> (XOR y <config.fe.TypeUInt32()> (Signmask y)) (Signmask y)))) // negate y if negative - (Signmask (XOR <config.fe.TypeUInt32()> x y))) (Signmask (XOR <config.fe.TypeUInt32()> x y))) -(Div32u x y) -> (Select0 <config.fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) + (SUB (XOR <fe.TypeUInt32()> // negate the result if one operand is negative + (Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} + (SUB <fe.TypeUInt32()> (XOR x <fe.TypeUInt32()> (Signmask x)) (Signmask x)) // negate x if negative + (SUB <fe.TypeUInt32()> (XOR y <fe.TypeUInt32()> (Signmask y)) (Signmask y)))) // negate y if negative + (Signmask (XOR <fe.TypeUInt32()> x y))) (Signmask (XOR <fe.TypeUInt32()> x y))) +(Div32u x y) -> (Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) (Div16 x y) -> (Div32 (SignExt16to32 x) (SignExt16to32 y)) (Div16u x y) -> (Div32u (ZeroExt16to32 x) (ZeroExt16to32 y)) (Div8 x y) -> (Div32 (SignExt8to32 x) (SignExt8to32 y)) @@ -48,12 +48,12 @@ (Div64F x y) -> (DIVD x y) (Mod32 x y) -> - (SUB (XOR <config.fe.TypeUInt32()> // negate the result if x is negative - (Select1 <config.fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} - (SUB <config.fe.TypeUInt32()> (XOR <config.fe.TypeUInt32()> x (Signmask x)) (Signmask x)) // negate x if negative - (SUB <config.fe.TypeUInt32()> (XOR <config.fe.TypeUInt32()> y (Signmask y)) (Signmask y)))) // negate y if negative + (SUB (XOR <fe.TypeUInt32()> // negate the result if x is negative + (Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} + (SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> x (Signmask x)) (Signmask x)) // negate x if negative + (SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> y (Signmask y)) (Signmask y)))) // negate y if negative (Signmask x)) (Signmask x)) -(Mod32u x y) -> (Select1 <config.fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) +(Mod32u x y) -> (Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) (Mod16 x y) -> (Mod32 (SignExt16to32 x) (SignExt16to32 y)) (Mod16u x y) -> (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y)) (Mod8 x y) -> (Mod32 (SignExt8to32 x) (SignExt8to32 y)) @@ -111,7 +111,7 @@ // boolean ops -- booleans are represented with 0=false, 1=true (AndB x y) -> (AND x y) (OrB x y) -> (OR x y) -(EqB x y) -> (XORconst [1] (XOR <config.fe.TypeBool()> x y)) +(EqB x y) -> (XORconst [1] (XOR <fe.TypeBool()> x y)) (NeqB x y) -> (XOR x y) (Not x) -> (XORconst [1] x) @@ -160,11 +160,11 @@ (Rsh32x64 x (Const64 [c])) && uint64(c) < 32 -> (SRAconst x [c]) (Rsh32Ux64 x (Const64 [c])) && uint64(c) < 32 -> (SRLconst x [c]) (Lsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SLLconst x [c]) -(Rsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) -(Rsh16Ux64 x (Const64 [c])) && uint64(c) < 16 -> (SRLconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) +(Rsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) +(Rsh16Ux64 x (Const64 [c])) && uint64(c) < 16 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) (Lsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SLLconst x [c]) -(Rsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) -(Rsh8Ux64 x (Const64 [c])) && uint64(c) < 8 -> (SRLconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) +(Rsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) +(Rsh8Ux64 x (Const64 [c])) && uint64(c) < 8 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) // large constant shifts (Lsh32x64 _ (Const64 [c])) && uint64(c) >= 32 -> (Const32 [0]) @@ -176,8 +176,8 @@ // large constant signed right shift, we leave the sign bit (Rsh32x64 x (Const64 [c])) && uint64(c) >= 32 -> (SRAconst x [31]) -(Rsh16x64 x (Const64 [c])) && uint64(c) >= 16 -> (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [31]) -(Rsh8x64 x (Const64 [c])) && uint64(c) >= 8 -> (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [31]) +(Rsh16x64 x (Const64 [c])) && uint64(c) >= 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31]) +(Rsh8x64 x (Const64 [c])) && uint64(c) >= 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31]) // constants (Const8 [val]) -> (MOVWconst [val]) @@ -204,7 +204,7 @@ (SignExt16to32 x) -> (MOVHreg x) (Signmask x) -> (SRAconst x [31]) -(Zeromask x) -> (SRAconst (RSBshiftRL <config.fe.TypeInt32()> x x [1]) [31]) // sign bit of uint32(x)>>1 - x +(Zeromask x) -> (SRAconst (RSBshiftRL <fe.TypeInt32()> x x [1]) [31]) // sign bit of uint32(x)>>1 - x (Slicemask <t> x) -> (SRAconst (RSBconst <t> [0] x) [31]) // float <-> int conversion diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules index 0654024ebc..d1bb9ae624 100644 --- a/src/cmd/compile/internal/ssa/gen/ARM64.rules +++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules @@ -27,8 +27,8 @@ (Hmul64 x y) -> (MULH x y) (Hmul64u x y) -> (UMULH x y) -(Hmul32 x y) -> (SRAconst (MULL <config.fe.TypeInt64()> x y) [32]) -(Hmul32u x y) -> (SRAconst (UMULL <config.fe.TypeUInt64()> x y) [32]) +(Hmul32 x y) -> (SRAconst (MULL <fe.TypeInt64()> x y) [32]) +(Hmul32u x y) -> (SRAconst (UMULL <fe.TypeUInt64()> x y) [32]) (Div64 x y) -> (DIV x y) (Div64u x y) -> (UDIV x y) @@ -86,20 +86,20 @@ (Ctz64 <t> x) -> (CLZ (RBIT <t> x)) (Ctz32 <t> x) -> (CLZW (RBITW <t> x)) -(BitLen64 x) -> (SUB (MOVDconst [64]) (CLZ <config.fe.TypeInt()> x)) +(BitLen64 x) -> (SUB (MOVDconst [64]) (CLZ <fe.TypeInt()> x)) (Bswap64 x) -> (REV x) (Bswap32 x) -> (REVW x) (BitRev64 x) -> (RBIT x) (BitRev32 x) -> (RBITW x) -(BitRev16 x) -> (SRLconst [48] (RBIT <config.fe.TypeUInt64()> x)) -(BitRev8 x) -> (SRLconst [56] (RBIT <config.fe.TypeUInt64()> x)) +(BitRev16 x) -> (SRLconst [48] (RBIT <fe.TypeUInt64()> x)) +(BitRev8 x) -> (SRLconst [56] (RBIT <fe.TypeUInt64()> x)) // boolean ops -- booleans are represented with 0=false, 1=true (AndB x y) -> (AND x y) (OrB x y) -> (OR x y) -(EqB x y) -> (XOR (MOVDconst [1]) (XOR <config.fe.TypeBool()> x y)) +(EqB x y) -> (XOR (MOVDconst [1]) (XOR <fe.TypeBool()> x y)) (NeqB x y) -> (XOR x y) (Not x) -> (XOR (MOVDconst [1]) x) diff --git a/src/cmd/compile/internal/ssa/gen/MIPS.rules b/src/cmd/compile/internal/ssa/gen/MIPS.rules index 766c25fa53..d210d5e60c 100644 --- a/src/cmd/compile/internal/ssa/gen/MIPS.rules +++ b/src/cmd/compile/internal/ssa/gen/MIPS.rules @@ -10,7 +10,7 @@ (Add64F x y) -> (ADDD x y) (Select0 (Add32carry <t> x y)) -> (ADD <t.FieldType(0)> x y) -(Select1 (Add32carry <t> x y)) -> (SGTU <config.fe.TypeBool()> x (ADD <t.FieldType(0)> x y)) +(Select1 (Add32carry <t> x y)) -> (SGTU <fe.TypeBool()> x (ADD <t.FieldType(0)> x y)) (Add32withcarry <t> x y c) -> (ADD c (ADD <t> x y)) (SubPtr x y) -> (SUB x y) @@ -21,7 +21,7 @@ (Sub64F x y) -> (SUBD x y) (Select0 (Sub32carry <t> x y)) -> (SUB <t.FieldType(0)> x y) -(Select1 (Sub32carry <t> x y)) -> (SGTU <config.fe.TypeBool()> (SUB <t.FieldType(0)> x y) x) +(Select1 (Sub32carry <t> x y)) -> (SGTU <fe.TypeBool()> (SUB <t.FieldType(0)> x y) x) (Sub32withcarry <t> x y c) -> (SUB (SUB <t> x y) c) (Mul32 x y) -> (MUL x y) @@ -72,11 +72,11 @@ (Rsh32x64 x (Const64 [c])) && uint32(c) < 32 -> (SRAconst x [c]) (Rsh32Ux64 x (Const64 [c])) && uint32(c) < 32 -> (SRLconst x [c]) (Lsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SLLconst x [c]) -(Rsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) -(Rsh16Ux64 x (Const64 [c])) && uint32(c) < 16 -> (SRLconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) +(Rsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) +(Rsh16Ux64 x (Const64 [c])) && uint32(c) < 16 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) (Lsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SLLconst x [c]) -(Rsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) -(Rsh8Ux64 x (Const64 [c])) && uint32(c) < 8 -> (SRLconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) +(Rsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) +(Rsh8Ux64 x (Const64 [c])) && uint32(c) < 8 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) // large constant shifts (Lsh32x64 _ (Const64 [c])) && uint32(c) >= 32 -> (MOVWconst [0]) @@ -88,8 +88,8 @@ // large constant signed right shift, we leave the sign bit (Rsh32x64 x (Const64 [c])) && uint32(c) >= 32 -> (SRAconst x [31]) -(Rsh16x64 x (Const64 [c])) && uint32(c) >= 16 -> (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [31]) -(Rsh8x64 x (Const64 [c])) && uint32(c) >= 8 -> (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [31]) +(Rsh16x64 x (Const64 [c])) && uint32(c) >= 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31]) +(Rsh8x64 x (Const64 [c])) && uint32(c) >= 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31]) // shifts // hardware instruction uses only the low 5 bits of the shift @@ -118,17 +118,17 @@ (Rsh8Ux16 <t> x y) -> (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y))) (Rsh8Ux8 <t> x y) -> (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y))) -(Rsh32x32 x y) -> (SRA x ( CMOVZ <config.fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) -(Rsh32x16 x y) -> (SRA x ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) -(Rsh32x8 x y) -> (SRA x ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) +(Rsh32x32 x y) -> (SRA x ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) +(Rsh32x16 x y) -> (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) +(Rsh32x8 x y) -> (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) -(Rsh16x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) -(Rsh16x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) -(Rsh16x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) +(Rsh16x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) +(Rsh16x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) +(Rsh16x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) -(Rsh8x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) -(Rsh8x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) -(Rsh8x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) +(Rsh8x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) +(Rsh8x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) +(Rsh8x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) // unary ops (Neg32 x) -> (NEG x) @@ -153,7 +153,7 @@ // boolean ops -- booleans are represented with 0=false, 1=true (AndB x y) -> (AND x y) (OrB x y) -> (OR x y) -(EqB x y) -> (XORconst [1] (XOR <config.fe.TypeBool()> x y)) +(EqB x y) -> (XORconst [1] (XOR <fe.TypeBool()> x y)) (NeqB x y) -> (XOR x y) (Not x) -> (XORconst [1] x) @@ -393,41 +393,41 @@ // AtomicOr8(ptr,val) -> LoweredAtomicOr(ptr&^3,uint32(val) << ((ptr & 3) * 8)) (AtomicOr8 ptr val mem) && !config.BigEndian -> - (LoweredAtomicOr (AND <config.fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) - (SLL <config.fe.TypeUInt32()> (ZeroExt8to32 val) - (SLLconst <config.fe.TypeUInt32()> [3] - (ANDconst <config.fe.TypeUInt32()> [3] ptr))) mem) + (LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) + (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) + (SLLconst <fe.TypeUInt32()> [3] + (ANDconst <fe.TypeUInt32()> [3] ptr))) mem) // AtomicAnd8(ptr,val) -> LoweredAtomicAnd(ptr&^3,(uint32(val) << ((ptr & 3) * 8)) | ^(uint32(0xFF) << ((ptr & 3) * 8)))) (AtomicAnd8 ptr val mem) && !config.BigEndian -> - (LoweredAtomicAnd (AND <config.fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) - (OR <config.fe.TypeUInt32()> (SLL <config.fe.TypeUInt32()> (ZeroExt8to32 val) - (SLLconst <config.fe.TypeUInt32()> [3] - (ANDconst <config.fe.TypeUInt32()> [3] ptr))) - (NORconst [0] <config.fe.TypeUInt32()> (SLL <config.fe.TypeUInt32()> - (MOVWconst [0xff]) (SLLconst <config.fe.TypeUInt32()> [3] - (ANDconst <config.fe.TypeUInt32()> [3] - (XORconst <config.fe.TypeUInt32()> [3] ptr)))))) mem) + (LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) + (OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) + (SLLconst <fe.TypeUInt32()> [3] + (ANDconst <fe.TypeUInt32()> [3] ptr))) + (NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> + (MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3] + (ANDconst <fe.TypeUInt32()> [3] + (XORconst <fe.TypeUInt32()> [3] ptr)))))) mem) // AtomicOr8(ptr,val) -> LoweredAtomicOr(ptr&^3,uint32(val) << (((ptr^3) & 3) * 8)) (AtomicOr8 ptr val mem) && config.BigEndian -> - (LoweredAtomicOr (AND <config.fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) - (SLL <config.fe.TypeUInt32()> (ZeroExt8to32 val) - (SLLconst <config.fe.TypeUInt32()> [3] - (ANDconst <config.fe.TypeUInt32()> [3] - (XORconst <config.fe.TypeUInt32()> [3] ptr)))) mem) + (LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) + (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) + (SLLconst <fe.TypeUInt32()> [3] + (ANDconst <fe.TypeUInt32()> [3] + (XORconst <fe.TypeUInt32()> [3] ptr)))) mem) // AtomicAnd8(ptr,val) -> LoweredAtomicAnd(ptr&^3,(uint32(val) << (((ptr^3) & 3) * 8)) | ^(uint32(0xFF) << (((ptr^3) & 3) * 8)))) (AtomicAnd8 ptr val mem) && config.BigEndian -> - (LoweredAtomicAnd (AND <config.fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) - (OR <config.fe.TypeUInt32()> (SLL <config.fe.TypeUInt32()> (ZeroExt8to32 val) - (SLLconst <config.fe.TypeUInt32()> [3] - (ANDconst <config.fe.TypeUInt32()> [3] - (XORconst <config.fe.TypeUInt32()> [3] ptr)))) - (NORconst [0] <config.fe.TypeUInt32()> (SLL <config.fe.TypeUInt32()> - (MOVWconst [0xff]) (SLLconst <config.fe.TypeUInt32()> [3] - (ANDconst <config.fe.TypeUInt32()> [3] - (XORconst <config.fe.TypeUInt32()> [3] ptr)))))) mem) + (LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) + (OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) + (SLLconst <fe.TypeUInt32()> [3] + (ANDconst <fe.TypeUInt32()> [3] + (XORconst <fe.TypeUInt32()> [3] ptr)))) + (NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> + (MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3] + (ANDconst <fe.TypeUInt32()> [3] + (XORconst <fe.TypeUInt32()> [3] ptr)))))) mem) // checks diff --git a/src/cmd/compile/internal/ssa/gen/MIPS64.rules b/src/cmd/compile/internal/ssa/gen/MIPS64.rules index a9ef12d970..a5dbcadf90 100644 --- a/src/cmd/compile/internal/ssa/gen/MIPS64.rules +++ b/src/cmd/compile/internal/ssa/gen/MIPS64.rules @@ -27,8 +27,8 @@ (Hmul64 x y) -> (Select0 (MULV x y)) (Hmul64u x y) -> (Select0 (MULVU x y)) -(Hmul32 x y) -> (SRAVconst (Select1 <config.fe.TypeInt64()> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32]) -(Hmul32u x y) -> (SRLVconst (Select1 <config.fe.TypeUInt64()> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32]) +(Hmul32 x y) -> (SRAVconst (Select1 <fe.TypeInt64()> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32]) +(Hmul32u x y) -> (SRLVconst (Select1 <fe.TypeUInt64()> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32]) (Div64 x y) -> (Select1 (DIVV x y)) (Div64u x y) -> (Select1 (DIVVU x y)) @@ -71,65 +71,65 @@ // shifts // hardware instruction uses only the low 6 bits of the shift // we compare to 64 to ensure Go semantics for large shifts -(Lsh64x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) -(Lsh64x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) -(Lsh64x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) -(Lsh64x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) - -(Lsh32x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) -(Lsh32x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) -(Lsh32x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) -(Lsh32x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) - -(Lsh16x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) -(Lsh16x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) -(Lsh16x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) -(Lsh16x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) - -(Lsh8x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) -(Lsh8x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) -(Lsh8x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) -(Lsh8x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) - -(Rsh64Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SRLV <t> x y)) -(Rsh64Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y))) -(Rsh64Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y))) -(Rsh64Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y))) - -(Rsh32Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y)) -(Rsh32Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y))) -(Rsh32Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y))) -(Rsh32Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y))) - -(Rsh16Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y)) -(Rsh16Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y))) -(Rsh16Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y))) -(Rsh16Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y))) - -(Rsh8Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y)) -(Rsh8Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y))) -(Rsh8Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y))) -(Rsh8Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y))) - -(Rsh64x64 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <config.fe.TypeUInt64()> [63]))) y)) -(Rsh64x32 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) -(Rsh64x16 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) -(Rsh64x8 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) - -(Rsh32x64 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <config.fe.TypeUInt64()> [63]))) y)) -(Rsh32x32 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) -(Rsh32x16 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) -(Rsh32x8 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) - -(Rsh16x64 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <config.fe.TypeUInt64()> [63]))) y)) -(Rsh16x32 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) -(Rsh16x16 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) -(Rsh16x8 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) - -(Rsh8x64 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <config.fe.TypeUInt64()> [63]))) y)) -(Rsh8x32 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) -(Rsh8x16 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) -(Rsh8x8 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) +(Lsh64x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) +(Lsh64x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) +(Lsh64x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) +(Lsh64x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) + +(Lsh32x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) +(Lsh32x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) +(Lsh32x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) +(Lsh32x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) + +(Lsh16x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) +(Lsh16x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) +(Lsh16x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) +(Lsh16x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) + +(Lsh8x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) +(Lsh8x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) +(Lsh8x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) +(Lsh8x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) + +(Rsh64Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> x y)) +(Rsh64Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y))) +(Rsh64Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y))) +(Rsh64Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y))) + +(Rsh32Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y)) +(Rsh32Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y))) +(Rsh32Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y))) +(Rsh32Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y))) + +(Rsh16Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y)) +(Rsh16Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y))) +(Rsh16Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y))) +(Rsh16Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y))) + +(Rsh8Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y)) +(Rsh8Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y))) +(Rsh8Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y))) +(Rsh8Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y))) + +(Rsh64x64 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) +(Rsh64x32 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) +(Rsh64x16 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) +(Rsh64x8 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) + +(Rsh32x64 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) +(Rsh32x32 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) +(Rsh32x16 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) +(Rsh32x8 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) + +(Rsh16x64 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) +(Rsh16x32 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) +(Rsh16x16 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) +(Rsh16x8 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) + +(Rsh8x64 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) +(Rsh8x32 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) +(Rsh8x16 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) +(Rsh8x8 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) // unary ops (Neg64 x) -> (NEGV x) @@ -147,7 +147,7 @@ // boolean ops -- booleans are represented with 0=false, 1=true (AndB x y) -> (AND x y) (OrB x y) -> (OR x y) -(EqB x y) -> (XOR (MOVVconst [1]) (XOR <config.fe.TypeBool()> x y)) +(EqB x y) -> (XOR (MOVVconst [1]) (XOR <fe.TypeBool()> x y)) (NeqB x y) -> (XOR x y) (Not x) -> (XORconst [1] x) diff --git a/src/cmd/compile/internal/ssa/gen/PPC64.rules b/src/cmd/compile/internal/ssa/gen/PPC64.rules index 9fe0eadf71..a0b5578d7e 100644 --- a/src/cmd/compile/internal/ssa/gen/PPC64.rules +++ b/src/cmd/compile/internal/ssa/gen/PPC64.rules @@ -154,72 +154,72 @@ (Rsh8x32 x (MOVDconst [c])) && uint32(c) < 8 -> (SRAWconst (SignExt8to32 x) [c]) (Rsh8Ux32 x (MOVDconst [c])) && uint32(c) < 8 -> (SRWconst (ZeroExt8to32 x) [c]) -(Rsh64x64 x y) -> (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) -(Rsh64Ux64 x y) -> (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) -(Lsh64x64 x y) -> (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) +(Rsh64x64 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) +(Rsh64Ux64 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) +(Lsh64x64 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) -(Rsh32x64 x y) -> (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) -(Rsh32Ux64 x y) -> (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) -(Lsh32x64 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) +(Rsh32x64 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) +(Rsh32Ux64 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) +(Lsh32x64 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) -(Rsh16x64 x y) -> (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) -(Rsh16Ux64 x y) -> (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) -(Lsh16x64 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) +(Rsh16x64 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) +(Rsh16Ux64 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) +(Lsh16x64 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) -(Rsh8x64 x y) -> (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) -(Rsh8Ux64 x y) -> (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) -(Lsh8x64 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) +(Rsh8x64 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) +(Rsh8Ux64 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) +(Lsh8x64 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) -(Rsh64x32 x y) -> (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) -(Rsh64Ux32 x y) -> (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) -(Lsh64x32 x y) -> (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) +(Rsh64x32 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) +(Rsh64Ux32 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) +(Lsh64x32 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) -(Rsh32x32 x y) -> (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) -(Rsh32Ux32 x y) -> (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) -(Lsh32x32 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) +(Rsh32x32 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) +(Rsh32Ux32 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) +(Lsh32x32 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) -(Rsh16x32 x y) -> (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) -(Rsh16Ux32 x y) -> (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) -(Lsh16x32 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) +(Rsh16x32 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) +(Rsh16Ux32 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) +(Lsh16x32 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) -(Rsh8x32 x y) -> (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) -(Rsh8Ux32 x y) -> (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) -(Lsh8x32 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) +(Rsh8x32 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) +(Rsh8Ux32 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) +(Lsh8x32 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) -(Rsh64x16 x y) -> (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) -(Rsh64Ux16 x y) -> (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) -(Lsh64x16 x y) -> (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) +(Rsh64x16 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) +(Rsh64Ux16 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) +(Lsh64x16 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) -(Rsh32x16 x y) -> (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) -(Rsh32Ux16 x y) -> (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) -(Lsh32x16 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) +(Rsh32x16 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) +(Rsh32Ux16 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) +(Lsh32x16 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) -(Rsh16x16 x y) -> (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) -(Rsh16Ux16 x y) -> (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) -(Lsh16x16 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) +(Rsh16x16 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) +(Rsh16Ux16 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) +(Lsh16x16 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) -(Rsh8x16 x y) -> (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) -(Rsh8Ux16 x y) -> (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) -(Lsh8x16 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) +(Rsh8x16 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) +(Rsh8Ux16 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) +(Lsh8x16 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) -(Rsh64x8 x y) -> (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) -(Rsh64Ux8 x y) -> (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) -(Lsh64x8 x y) -> (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) +(Rsh64x8 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) +(Rsh64Ux8 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) +(Lsh64x8 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) -(Rsh32x8 x y) -> (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) -(Rsh32Ux8 x y) -> (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) -(Lsh32x8 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) +(Rsh32x8 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) +(Rsh32Ux8 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) +(Lsh32x8 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) -(Rsh16x8 x y) -> (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) -(Rsh16Ux8 x y) -> (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) -(Lsh16x8 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) +(Rsh16x8 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) +(Rsh16Ux8 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) +(Lsh16x8 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) -(Rsh8x8 x y) -> (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) -(Rsh8Ux8 x y) -> (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) -(Lsh8x8 x y) -> (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) +(Rsh8x8 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) +(Rsh8Ux8 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) +(Lsh8x8 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) // Cleaning up shift ops when input is masked (MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _))) && c < 0 && d > 0 && c + d < 0 -> (MOVDconst [-1]) @@ -233,7 +233,7 @@ (Addr {sym} base) -> (MOVDaddr {sym} base) // (Addr {sym} base) -> (ADDconst {sym} base) -(OffPtr [off] ptr) -> (ADD (MOVDconst <config.Frontend().TypeInt64()> [off]) ptr) +(OffPtr [off] ptr) -> (ADD (MOVDconst <fe.TypeInt64()> [off]) ptr) (And64 x y) -> (AND x y) (And32 x y) -> (AND x y) diff --git a/src/cmd/compile/internal/ssa/gen/S390X.rules b/src/cmd/compile/internal/ssa/gen/S390X.rules index c1e821a7ee..41cd0f2465 100644 --- a/src/cmd/compile/internal/ssa/gen/S390X.rules +++ b/src/cmd/compile/internal/ssa/gen/S390X.rules @@ -437,7 +437,7 @@ (If (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no) -> (GTF cmp yes no) (If (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no) -> (GEF cmp yes no) -(If cond yes no) -> (NE (CMPWconst [0] (MOVBZreg <config.fe.TypeBool()> cond)) yes no) +(If cond yes no) -> (NE (CMPWconst [0] (MOVBZreg <fe.TypeBool()> cond)) yes no) // *************************** // Above: lowering rules diff --git a/src/cmd/compile/internal/ssa/gen/dec.rules b/src/cmd/compile/internal/ssa/gen/dec.rules index b7050d29db..5fb5c47ec3 100644 --- a/src/cmd/compile/internal/ssa/gen/dec.rules +++ b/src/cmd/compile/internal/ssa/gen/dec.rules @@ -13,28 +13,28 @@ (Load <t> ptr mem) && t.IsComplex() && t.Size() == 8 -> (ComplexMake - (Load <config.fe.TypeFloat32()> ptr mem) - (Load <config.fe.TypeFloat32()> - (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] ptr) + (Load <fe.TypeFloat32()> ptr mem) + (Load <fe.TypeFloat32()> + (OffPtr <fe.TypeFloat32().PtrTo()> [4] ptr) mem) ) (Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 8 -> - (Store {config.fe.TypeFloat32()} - (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] dst) + (Store {fe.TypeFloat32()} + (OffPtr <fe.TypeFloat32().PtrTo()> [4] dst) imag - (Store {config.fe.TypeFloat32()} dst real mem)) + (Store {fe.TypeFloat32()} dst real mem)) (Load <t> ptr mem) && t.IsComplex() && t.Size() == 16 -> (ComplexMake - (Load <config.fe.TypeFloat64()> ptr mem) - (Load <config.fe.TypeFloat64()> - (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] ptr) + (Load <fe.TypeFloat64()> ptr mem) + (Load <fe.TypeFloat64()> + (OffPtr <fe.TypeFloat64().PtrTo()> [8] ptr) mem) ) (Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 16 -> - (Store {config.fe.TypeFloat64()} - (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] dst) + (Store {fe.TypeFloat64()} + (OffPtr <fe.TypeFloat64().PtrTo()> [8] dst) imag - (Store {config.fe.TypeFloat64()} dst real mem)) + (Store {fe.TypeFloat64()} dst real mem)) // string ops (StringPtr (StringMake ptr _)) -> ptr @@ -42,15 +42,15 @@ (Load <t> ptr mem) && t.IsString() -> (StringMake - (Load <config.fe.TypeBytePtr()> ptr mem) - (Load <config.fe.TypeInt()> - (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr) + (Load <fe.TypeBytePtr()> ptr mem) + (Load <fe.TypeInt()> + (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem)) (Store dst (StringMake ptr len) mem) -> - (Store {config.fe.TypeInt()} - (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) + (Store {fe.TypeInt()} + (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) len - (Store {config.fe.TypeBytePtr()} dst ptr mem)) + (Store {fe.TypeBytePtr()} dst ptr mem)) // slice ops (SlicePtr (SliceMake ptr _ _ )) -> ptr @@ -60,20 +60,20 @@ (Load <t> ptr mem) && t.IsSlice() -> (SliceMake (Load <t.ElemType().PtrTo()> ptr mem) - (Load <config.fe.TypeInt()> - (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr) + (Load <fe.TypeInt()> + (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem) - (Load <config.fe.TypeInt()> - (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr) + (Load <fe.TypeInt()> + (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr) mem)) (Store dst (SliceMake ptr len cap) mem) -> - (Store {config.fe.TypeInt()} - (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) + (Store {fe.TypeInt()} + (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) cap - (Store {config.fe.TypeInt()} - (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) + (Store {fe.TypeInt()} + (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) len - (Store {config.fe.TypeBytePtr()} dst ptr mem))) + (Store {fe.TypeBytePtr()} dst ptr mem))) // interface ops (ITab (IMake itab _)) -> itab @@ -81,12 +81,12 @@ (Load <t> ptr mem) && t.IsInterface() -> (IMake - (Load <config.fe.TypeBytePtr()> ptr mem) - (Load <config.fe.TypeBytePtr()> - (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr) + (Load <fe.TypeBytePtr()> ptr mem) + (Load <fe.TypeBytePtr()> + (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr) mem)) (Store dst (IMake itab data) mem) -> - (Store {config.fe.TypeBytePtr()} - (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) + (Store {fe.TypeBytePtr()} + (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) data - (Store {config.fe.TypeUintptr()} dst itab mem)) + (Store {fe.TypeUintptr()} dst itab mem)) diff --git a/src/cmd/compile/internal/ssa/gen/dec64.rules b/src/cmd/compile/internal/ssa/gen/dec64.rules index 18adb96a73..03c14a36fe 100644 --- a/src/cmd/compile/internal/ssa/gen/dec64.rules +++ b/src/cmd/compile/internal/ssa/gen/dec64.rules @@ -12,23 +12,23 @@ (Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && t.IsSigned() -> (Int64Make - (Load <config.fe.TypeInt32()> (OffPtr <config.fe.TypeInt32().PtrTo()> [4] ptr) mem) - (Load <config.fe.TypeUInt32()> ptr mem)) + (Load <fe.TypeInt32()> (OffPtr <fe.TypeInt32().PtrTo()> [4] ptr) mem) + (Load <fe.TypeUInt32()> ptr mem)) (Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && !t.IsSigned() -> (Int64Make - (Load <config.fe.TypeUInt32()> (OffPtr <config.fe.TypeUInt32().PtrTo()> [4] ptr) mem) - (Load <config.fe.TypeUInt32()> ptr mem)) + (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem) + (Load <fe.TypeUInt32()> ptr mem)) (Load <t> ptr mem) && is64BitInt(t) && config.BigEndian && t.IsSigned() -> (Int64Make - (Load <config.fe.TypeInt32()> ptr mem) - (Load <config.fe.TypeUInt32()> (OffPtr <config.fe.TypeUInt32().PtrTo()> [4] ptr) mem)) + (Load <fe.TypeInt32()> ptr mem) + (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem)) (Load <t> ptr mem) && is64BitInt(t) && config.BigEndian && !t.IsSigned() -> (Int64Make - (Load <config.fe.TypeUInt32()> ptr mem) - (Load <config.fe.TypeUInt32()> (OffPtr <config.fe.TypeUInt32().PtrTo()> [4] ptr) mem)) + (Load <fe.TypeUInt32()> ptr mem) + (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem)) (Store {t} dst (Int64Make hi lo) mem) && t.(Type).Size() == 8 && !config.BigEndian -> (Store {hi.Type} @@ -44,94 +44,94 @@ (Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() -> (Int64Make - (Arg <config.fe.TypeInt32()> {n} [off+4]) - (Arg <config.fe.TypeUInt32()> {n} [off])) + (Arg <fe.TypeInt32()> {n} [off+4]) + (Arg <fe.TypeUInt32()> {n} [off])) (Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() -> (Int64Make - (Arg <config.fe.TypeUInt32()> {n} [off+4]) - (Arg <config.fe.TypeUInt32()> {n} [off])) + (Arg <fe.TypeUInt32()> {n} [off+4]) + (Arg <fe.TypeUInt32()> {n} [off])) (Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() -> (Int64Make - (Arg <config.fe.TypeInt32()> {n} [off]) - (Arg <config.fe.TypeUInt32()> {n} [off+4])) + (Arg <fe.TypeInt32()> {n} [off]) + (Arg <fe.TypeUInt32()> {n} [off+4])) (Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() -> (Int64Make - (Arg <config.fe.TypeUInt32()> {n} [off]) - (Arg <config.fe.TypeUInt32()> {n} [off+4])) + (Arg <fe.TypeUInt32()> {n} [off]) + (Arg <fe.TypeUInt32()> {n} [off+4])) (Add64 x y) -> (Int64Make - (Add32withcarry <config.fe.TypeInt32()> + (Add32withcarry <fe.TypeInt32()> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y)))) - (Select0 <config.fe.TypeUInt32()> (Add32carry (Int64Lo x) (Int64Lo y)))) + (Select0 <fe.TypeUInt32()> (Add32carry (Int64Lo x) (Int64Lo y)))) (Sub64 x y) -> (Int64Make - (Sub32withcarry <config.fe.TypeInt32()> + (Sub32withcarry <fe.TypeInt32()> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y)))) - (Select0 <config.fe.TypeUInt32()> (Sub32carry (Int64Lo x) (Int64Lo y)))) + (Select0 <fe.TypeUInt32()> (Sub32carry (Int64Lo x) (Int64Lo y)))) (Mul64 x y) -> (Int64Make - (Add32 <config.fe.TypeUInt32()> - (Mul32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Hi y)) - (Add32 <config.fe.TypeUInt32()> - (Mul32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Lo y)) - (Select0 <config.fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) - (Select1 <config.fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y)))) + (Add32 <fe.TypeUInt32()> + (Mul32 <fe.TypeUInt32()> (Int64Lo x) (Int64Hi y)) + (Add32 <fe.TypeUInt32()> + (Mul32 <fe.TypeUInt32()> (Int64Hi x) (Int64Lo y)) + (Select0 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) + (Select1 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y)))) (And64 x y) -> (Int64Make - (And32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) - (And32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) + (And32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) + (And32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) (Or64 x y) -> (Int64Make - (Or32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) - (Or32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) + (Or32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) + (Or32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) (Xor64 x y) -> (Int64Make - (Xor32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) - (Xor32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) + (Xor32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) + (Xor32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) (Neg64 <t> x) -> (Sub64 (Const64 <t> [0]) x) (Com64 x) -> (Int64Make - (Com32 <config.fe.TypeUInt32()> (Int64Hi x)) - (Com32 <config.fe.TypeUInt32()> (Int64Lo x))) + (Com32 <fe.TypeUInt32()> (Int64Hi x)) + (Com32 <fe.TypeUInt32()> (Int64Lo x))) (Ctz64 x) -> - (Add32 <config.fe.TypeUInt32()> - (Ctz32 <config.fe.TypeUInt32()> (Int64Lo x)) - (And32 <config.fe.TypeUInt32()> - (Com32 <config.fe.TypeUInt32()> (Zeromask (Int64Lo x))) - (Ctz32 <config.fe.TypeUInt32()> (Int64Hi x)))) + (Add32 <fe.TypeUInt32()> + (Ctz32 <fe.TypeUInt32()> (Int64Lo x)) + (And32 <fe.TypeUInt32()> + (Com32 <fe.TypeUInt32()> (Zeromask (Int64Lo x))) + (Ctz32 <fe.TypeUInt32()> (Int64Hi x)))) (BitLen64 x) -> - (Add32 <config.fe.TypeInt()> - (BitLen32 <config.fe.TypeInt()> (Int64Hi x)) - (BitLen32 <config.fe.TypeInt()> - (Or32 <config.fe.TypeUInt32()> + (Add32 <fe.TypeInt()> + (BitLen32 <fe.TypeInt()> (Int64Hi x)) + (BitLen32 <fe.TypeInt()> + (Or32 <fe.TypeUInt32()> (Int64Lo x) (Zeromask (Int64Hi x))))) (Bswap64 x) -> (Int64Make - (Bswap32 <config.fe.TypeUInt32()> (Int64Lo x)) - (Bswap32 <config.fe.TypeUInt32()> (Int64Hi x))) + (Bswap32 <fe.TypeUInt32()> (Int64Lo x)) + (Bswap32 <fe.TypeUInt32()> (Int64Hi x))) (SignExt32to64 x) -> (Int64Make (Signmask x) x) (SignExt16to64 x) -> (SignExt32to64 (SignExt16to32 x)) (SignExt8to64 x) -> (SignExt32to64 (SignExt8to32 x)) -(ZeroExt32to64 x) -> (Int64Make (Const32 <config.fe.TypeUInt32()> [0]) x) +(ZeroExt32to64 x) -> (Int64Make (Const32 <fe.TypeUInt32()> [0]) x) (ZeroExt16to64 x) -> (ZeroExt32to64 (ZeroExt16to32 x)) (ZeroExt8to64 x) -> (ZeroExt32to64 (ZeroExt8to32 x)) @@ -170,160 +170,160 @@ // turn x64 non-constant shifts to x32 shifts // if high 32-bit of the shift is nonzero, make a huge shift (Lsh64x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Lsh64x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Lsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh64x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Rsh64x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Rsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh64Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Rsh64Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Rsh64Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Lsh32x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Lsh32x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Lsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh32x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Rsh32x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Rsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh32Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Rsh32Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Rsh32Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Lsh16x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Lsh16x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Lsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh16x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Rsh16x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Rsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh16Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Rsh16Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Rsh16Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Lsh8x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Lsh8x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Lsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh8x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Rsh8x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Rsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh8Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> - (Rsh8Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + (Rsh8Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) // 64x left shift // result.hi = hi<<s | lo>>(32-s) | lo<<(s-32) // >> is unsigned, large shifts result 0 // result.lo = lo<<s (Lsh64x32 (Int64Make hi lo) s) -> (Int64Make - (Or32 <config.fe.TypeUInt32()> - (Or32 <config.fe.TypeUInt32()> - (Lsh32x32 <config.fe.TypeUInt32()> hi s) - (Rsh32Ux32 <config.fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Lsh32x32 <fe.TypeUInt32()> hi s) + (Rsh32Ux32 <fe.TypeUInt32()> lo - (Sub32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [32]) s))) - (Lsh32x32 <config.fe.TypeUInt32()> + (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) + (Lsh32x32 <fe.TypeUInt32()> lo - (Sub32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [32])))) - (Lsh32x32 <config.fe.TypeUInt32()> lo s)) + (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32])))) + (Lsh32x32 <fe.TypeUInt32()> lo s)) (Lsh64x16 (Int64Make hi lo) s) -> (Int64Make - (Or32 <config.fe.TypeUInt32()> - (Or32 <config.fe.TypeUInt32()> - (Lsh32x16 <config.fe.TypeUInt32()> hi s) - (Rsh32Ux16 <config.fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Lsh32x16 <fe.TypeUInt32()> hi s) + (Rsh32Ux16 <fe.TypeUInt32()> lo - (Sub16 <config.fe.TypeUInt16()> (Const16 <config.fe.TypeUInt16()> [32]) s))) - (Lsh32x16 <config.fe.TypeUInt32()> + (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) + (Lsh32x16 <fe.TypeUInt32()> lo - (Sub16 <config.fe.TypeUInt16()> s (Const16 <config.fe.TypeUInt16()> [32])))) - (Lsh32x16 <config.fe.TypeUInt32()> lo s)) + (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32])))) + (Lsh32x16 <fe.TypeUInt32()> lo s)) (Lsh64x8 (Int64Make hi lo) s) -> (Int64Make - (Or32 <config.fe.TypeUInt32()> - (Or32 <config.fe.TypeUInt32()> - (Lsh32x8 <config.fe.TypeUInt32()> hi s) - (Rsh32Ux8 <config.fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Lsh32x8 <fe.TypeUInt32()> hi s) + (Rsh32Ux8 <fe.TypeUInt32()> lo - (Sub8 <config.fe.TypeUInt8()> (Const8 <config.fe.TypeUInt8()> [32]) s))) - (Lsh32x8 <config.fe.TypeUInt32()> + (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) + (Lsh32x8 <fe.TypeUInt32()> lo - (Sub8 <config.fe.TypeUInt8()> s (Const8 <config.fe.TypeUInt8()> [32])))) - (Lsh32x8 <config.fe.TypeUInt32()> lo s)) + (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32])))) + (Lsh32x8 <fe.TypeUInt32()> lo s)) // 64x unsigned right shift // result.hi = hi>>s // result.lo = lo>>s | hi<<(32-s) | hi>>(s-32) // >> is unsigned, large shifts result 0 (Rsh64Ux32 (Int64Make hi lo) s) -> (Int64Make - (Rsh32Ux32 <config.fe.TypeUInt32()> hi s) - (Or32 <config.fe.TypeUInt32()> - (Or32 <config.fe.TypeUInt32()> - (Rsh32Ux32 <config.fe.TypeUInt32()> lo s) - (Lsh32x32 <config.fe.TypeUInt32()> + (Rsh32Ux32 <fe.TypeUInt32()> hi s) + (Or32 <fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Rsh32Ux32 <fe.TypeUInt32()> lo s) + (Lsh32x32 <fe.TypeUInt32()> hi - (Sub32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [32]) s))) - (Rsh32Ux32 <config.fe.TypeUInt32()> + (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) + (Rsh32Ux32 <fe.TypeUInt32()> hi - (Sub32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [32]))))) + (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32]))))) (Rsh64Ux16 (Int64Make hi lo) s) -> (Int64Make - (Rsh32Ux16 <config.fe.TypeUInt32()> hi s) - (Or32 <config.fe.TypeUInt32()> - (Or32 <config.fe.TypeUInt32()> - (Rsh32Ux16 <config.fe.TypeUInt32()> lo s) - (Lsh32x16 <config.fe.TypeUInt32()> + (Rsh32Ux16 <fe.TypeUInt32()> hi s) + (Or32 <fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Rsh32Ux16 <fe.TypeUInt32()> lo s) + (Lsh32x16 <fe.TypeUInt32()> hi - (Sub16 <config.fe.TypeUInt16()> (Const16 <config.fe.TypeUInt16()> [32]) s))) - (Rsh32Ux16 <config.fe.TypeUInt32()> + (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) + (Rsh32Ux16 <fe.TypeUInt32()> hi - (Sub16 <config.fe.TypeUInt16()> s (Const16 <config.fe.TypeUInt16()> [32]))))) + (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32]))))) (Rsh64Ux8 (Int64Make hi lo) s) -> (Int64Make - (Rsh32Ux8 <config.fe.TypeUInt32()> hi s) - (Or32 <config.fe.TypeUInt32()> - (Or32 <config.fe.TypeUInt32()> - (Rsh32Ux8 <config.fe.TypeUInt32()> lo s) - (Lsh32x8 <config.fe.TypeUInt32()> + (Rsh32Ux8 <fe.TypeUInt32()> hi s) + (Or32 <fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Rsh32Ux8 <fe.TypeUInt32()> lo s) + (Lsh32x8 <fe.TypeUInt32()> hi - (Sub8 <config.fe.TypeUInt8()> (Const8 <config.fe.TypeUInt8()> [32]) s))) - (Rsh32Ux8 <config.fe.TypeUInt32()> + (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) + (Rsh32Ux8 <fe.TypeUInt32()> hi - (Sub8 <config.fe.TypeUInt8()> s (Const8 <config.fe.TypeUInt8()> [32]))))) + (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32]))))) // 64x signed right shift // result.hi = hi>>s // result.lo = lo>>s | hi<<(32-s) | (hi>>(s-32))&zeromask(s>>5) // hi>>(s-32) is signed, large shifts result 0/-1 (Rsh64x32 (Int64Make hi lo) s) -> (Int64Make - (Rsh32x32 <config.fe.TypeUInt32()> hi s) - (Or32 <config.fe.TypeUInt32()> - (Or32 <config.fe.TypeUInt32()> - (Rsh32Ux32 <config.fe.TypeUInt32()> lo s) - (Lsh32x32 <config.fe.TypeUInt32()> + (Rsh32x32 <fe.TypeUInt32()> hi s) + (Or32 <fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Rsh32Ux32 <fe.TypeUInt32()> lo s) + (Lsh32x32 <fe.TypeUInt32()> hi - (Sub32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [32]) s))) - (And32 <config.fe.TypeUInt32()> - (Rsh32x32 <config.fe.TypeUInt32()> + (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) + (And32 <fe.TypeUInt32()> + (Rsh32x32 <fe.TypeUInt32()> hi - (Sub32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [32]))) + (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32]))) (Zeromask - (Rsh32Ux32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [5])))))) + (Rsh32Ux32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [5])))))) (Rsh64x16 (Int64Make hi lo) s) -> (Int64Make - (Rsh32x16 <config.fe.TypeUInt32()> hi s) - (Or32 <config.fe.TypeUInt32()> - (Or32 <config.fe.TypeUInt32()> - (Rsh32Ux16 <config.fe.TypeUInt32()> lo s) - (Lsh32x16 <config.fe.TypeUInt32()> + (Rsh32x16 <fe.TypeUInt32()> hi s) + (Or32 <fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Rsh32Ux16 <fe.TypeUInt32()> lo s) + (Lsh32x16 <fe.TypeUInt32()> hi - (Sub16 <config.fe.TypeUInt16()> (Const16 <config.fe.TypeUInt16()> [32]) s))) - (And32 <config.fe.TypeUInt32()> - (Rsh32x16 <config.fe.TypeUInt32()> + (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) + (And32 <fe.TypeUInt32()> + (Rsh32x16 <fe.TypeUInt32()> hi - (Sub16 <config.fe.TypeUInt16()> s (Const16 <config.fe.TypeUInt16()> [32]))) + (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32]))) (Zeromask (ZeroExt16to32 - (Rsh16Ux32 <config.fe.TypeUInt16()> s (Const32 <config.fe.TypeUInt32()> [5]))))))) + (Rsh16Ux32 <fe.TypeUInt16()> s (Const32 <fe.TypeUInt32()> [5]))))))) (Rsh64x8 (Int64Make hi lo) s) -> (Int64Make - (Rsh32x8 <config.fe.TypeUInt32()> hi s) - (Or32 <config.fe.TypeUInt32()> - (Or32 <config.fe.TypeUInt32()> - (Rsh32Ux8 <config.fe.TypeUInt32()> lo s) - (Lsh32x8 <config.fe.TypeUInt32()> + (Rsh32x8 <fe.TypeUInt32()> hi s) + (Or32 <fe.TypeUInt32()> + (Or32 <fe.TypeUInt32()> + (Rsh32Ux8 <fe.TypeUInt32()> lo s) + (Lsh32x8 <fe.TypeUInt32()> hi - (Sub8 <config.fe.TypeUInt8()> (Const8 <config.fe.TypeUInt8()> [32]) s))) - (And32 <config.fe.TypeUInt32()> - (Rsh32x8 <config.fe.TypeUInt32()> + (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) + (And32 <fe.TypeUInt32()> + (Rsh32x8 <fe.TypeUInt32()> hi - (Sub8 <config.fe.TypeUInt8()> s (Const8 <config.fe.TypeUInt8()> [32]))) + (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32]))) (Zeromask (ZeroExt8to32 - (Rsh8Ux32 <config.fe.TypeUInt8()> s (Const32 <config.fe.TypeUInt32()> [5]))))))) + (Rsh8Ux32 <fe.TypeUInt8()> s (Const32 <fe.TypeUInt32()> [5]))))))) // 64xConst32 shifts // we probably do not need them -- lateopt may take care of them just fine @@ -333,48 +333,48 @@ // //(Lsh64x32 x (Const32 [c])) && c < 64 && c > 32 -> // (Int64Make -// (Lsh32x32 <config.fe.TypeUInt32()> (Int64Lo x) (Const32 <config.fe.TypeUInt32()> [c-32])) -// (Const32 <config.fe.TypeUInt32()> [0])) +// (Lsh32x32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c-32])) +// (Const32 <fe.TypeUInt32()> [0])) //(Rsh64x32 x (Const32 [c])) && c < 64 && c > 32 -> // (Int64Make // (Signmask (Int64Hi x)) -// (Rsh32x32 <config.fe.TypeInt32()> (Int64Hi x) (Const32 <config.fe.TypeUInt32()> [c-32]))) +// (Rsh32x32 <fe.TypeInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c-32]))) //(Rsh64Ux32 x (Const32 [c])) && c < 64 && c > 32 -> // (Int64Make -// (Const32 <config.fe.TypeUInt32()> [0]) -// (Rsh32Ux32 <config.fe.TypeUInt32()> (Int64Hi x) (Const32 <config.fe.TypeUInt32()> [c-32]))) +// (Const32 <fe.TypeUInt32()> [0]) +// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c-32]))) // -//(Lsh64x32 x (Const32 [32])) -> (Int64Make (Int64Lo x) (Const32 <config.fe.TypeUInt32()> [0])) +//(Lsh64x32 x (Const32 [32])) -> (Int64Make (Int64Lo x) (Const32 <fe.TypeUInt32()> [0])) //(Rsh64x32 x (Const32 [32])) -> (Int64Make (Signmask (Int64Hi x)) (Int64Hi x)) -//(Rsh64Ux32 x (Const32 [32])) -> (Int64Make (Const32 <config.fe.TypeUInt32()> [0]) (Int64Hi x)) +//(Rsh64Ux32 x (Const32 [32])) -> (Int64Make (Const32 <fe.TypeUInt32()> [0]) (Int64Hi x)) // //(Lsh64x32 x (Const32 [c])) && c < 32 && c > 0 -> // (Int64Make -// (Or32 <config.fe.TypeUInt32()> -// (Lsh32x32 <config.fe.TypeUInt32()> (Int64Hi x) (Const32 <config.fe.TypeUInt32()> [c])) -// (Rsh32Ux32 <config.fe.TypeUInt32()> (Int64Lo x) (Const32 <config.fe.TypeUInt32()> [32-c]))) -// (Lsh32x32 <config.fe.TypeUInt32()> (Int64Lo x) (Const32 <config.fe.TypeUInt32()> [c]))) +// (Or32 <fe.TypeUInt32()> +// (Lsh32x32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c])) +// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [32-c]))) +// (Lsh32x32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c]))) //(Rsh64x32 x (Const32 [c])) && c < 32 && c > 0 -> // (Int64Make -// (Rsh32x32 <config.fe.TypeInt32()> (Int64Hi x) (Const32 <config.fe.TypeUInt32()> [c])) -// (Or32 <config.fe.TypeUInt32()> -// (Rsh32Ux32 <config.fe.TypeUInt32()> (Int64Lo x) (Const32 <config.fe.TypeUInt32()> [c])) -// (Lsh32x32 <config.fe.TypeUInt32()> (Int64Hi x) (Const32 <config.fe.TypeUInt32()> [32-c])))) +// (Rsh32x32 <fe.TypeInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c])) +// (Or32 <fe.TypeUInt32()> +// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c])) +// (Lsh32x32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [32-c])))) //(Rsh64Ux32 x (Const32 [c])) && c < 32 && c > 0 -> // (Int64Make -// (Rsh32Ux32 <config.fe.TypeUInt32()> (Int64Hi x) (Const32 <config.fe.TypeUInt32()> [c])) -// (Or32 <config.fe.TypeUInt32()> -// (Rsh32Ux32 <config.fe.TypeUInt32()> (Int64Lo x) (Const32 <config.fe.TypeUInt32()> [c])) -// (Lsh32x32 <config.fe.TypeUInt32()> (Int64Hi x) (Const32 <config.fe.TypeUInt32()> [32-c])))) +// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c])) +// (Or32 <fe.TypeUInt32()> +// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c])) +// (Lsh32x32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [32-c])))) // //(Lsh64x32 x (Const32 [0])) -> x //(Rsh64x32 x (Const32 [0])) -> x //(Rsh64Ux32 x (Const32 [0])) -> x (Const64 <t> [c]) && t.IsSigned() -> - (Int64Make (Const32 <config.fe.TypeInt32()> [c>>32]) (Const32 <config.fe.TypeUInt32()> [int64(int32(c))])) + (Int64Make (Const32 <fe.TypeInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))])) (Const64 <t> [c]) && !t.IsSigned() -> - (Int64Make (Const32 <config.fe.TypeUInt32()> [c>>32]) (Const32 <config.fe.TypeUInt32()> [int64(int32(c))])) + (Int64Make (Const32 <fe.TypeUInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))])) (Eq64 x y) -> (AndB diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 029a2cad56..6be686134e 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -155,14 +155,14 @@ (Mul64 (Const64 [-1]) x) -> (Neg64 x) // Convert multiplication by a power of two to a shift. -(Mul8 <t> n (Const8 [c])) && isPowerOfTwo(c) -> (Lsh8x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(c)])) -(Mul16 <t> n (Const16 [c])) && isPowerOfTwo(c) -> (Lsh16x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(c)])) -(Mul32 <t> n (Const32 [c])) && isPowerOfTwo(c) -> (Lsh32x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(c)])) -(Mul64 <t> n (Const64 [c])) && isPowerOfTwo(c) -> (Lsh64x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(c)])) -(Mul8 <t> n (Const8 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg8 (Lsh8x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(-c)]))) -(Mul16 <t> n (Const16 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg16 (Lsh16x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(-c)]))) -(Mul32 <t> n (Const32 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg32 (Lsh32x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(-c)]))) -(Mul64 <t> n (Const64 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg64 (Lsh64x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(-c)]))) +(Mul8 <t> n (Const8 [c])) && isPowerOfTwo(c) -> (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) +(Mul16 <t> n (Const16 [c])) && isPowerOfTwo(c) -> (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) +(Mul32 <t> n (Const32 [c])) && isPowerOfTwo(c) -> (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) +(Mul64 <t> n (Const64 [c])) && isPowerOfTwo(c) -> (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) +(Mul8 <t> n (Const8 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg8 (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) +(Mul16 <t> n (Const16 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg16 (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) +(Mul32 <t> n (Const32 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg32 (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) +(Mul64 <t> n (Const64 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg64 (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) (Mod8 (Const8 [c]) (Const8 [d])) && d != 0 -> (Const8 [int64(int8(c % d))]) (Mod16 (Const16 [c]) (Const16 [d])) && d != 0 -> (Const16 [int64(int16(c % d))]) @@ -481,46 +481,46 @@ // ((x >> c1) << c2) >> c3 (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - -> (Rsh64Ux64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + -> (Rsh64Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - -> (Rsh32Ux64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + -> (Rsh32Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - -> (Rsh16Ux64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + -> (Rsh16Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - -> (Rsh8Ux64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + -> (Rsh8Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) // ((x << c1) >> c2) << c3 (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - -> (Lsh64x64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + -> (Lsh64x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - -> (Lsh32x64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + -> (Lsh32x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - -> (Lsh16x64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + -> (Lsh16x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - -> (Lsh8x64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + -> (Lsh8x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) // replace shifts with zero extensions -(Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (ZeroExt8to16 (Trunc16to8 <config.fe.TypeUInt8()> x)) -(Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (ZeroExt8to32 (Trunc32to8 <config.fe.TypeUInt8()> x)) -(Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (ZeroExt8to64 (Trunc64to8 <config.fe.TypeUInt8()> x)) -(Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (ZeroExt16to32 (Trunc32to16 <config.fe.TypeUInt16()> x)) -(Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (ZeroExt16to64 (Trunc64to16 <config.fe.TypeUInt16()> x)) -(Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (ZeroExt32to64 (Trunc64to32 <config.fe.TypeUInt32()> x)) +(Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (ZeroExt8to16 (Trunc16to8 <fe.TypeUInt8()> x)) +(Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (ZeroExt8to32 (Trunc32to8 <fe.TypeUInt8()> x)) +(Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (ZeroExt8to64 (Trunc64to8 <fe.TypeUInt8()> x)) +(Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (ZeroExt16to32 (Trunc32to16 <fe.TypeUInt16()> x)) +(Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (ZeroExt16to64 (Trunc64to16 <fe.TypeUInt16()> x)) +(Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (ZeroExt32to64 (Trunc64to32 <fe.TypeUInt32()> x)) // replace shifts with sign extensions -(Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (SignExt8to16 (Trunc16to8 <config.fe.TypeInt8()> x)) -(Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (SignExt8to32 (Trunc32to8 <config.fe.TypeInt8()> x)) -(Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (SignExt8to64 (Trunc64to8 <config.fe.TypeInt8()> x)) -(Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (SignExt16to32 (Trunc32to16 <config.fe.TypeInt16()> x)) -(Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (SignExt16to64 (Trunc64to16 <config.fe.TypeInt16()> x)) -(Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (SignExt32to64 (Trunc64to32 <config.fe.TypeInt32()> x)) +(Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (SignExt8to16 (Trunc16to8 <fe.TypeInt8()> x)) +(Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (SignExt8to32 (Trunc32to8 <fe.TypeInt8()> x)) +(Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (SignExt8to64 (Trunc64to8 <fe.TypeInt8()> x)) +(Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (SignExt16to32 (Trunc32to16 <fe.TypeInt16()> x)) +(Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (SignExt16to64 (Trunc64to16 <fe.TypeInt16()> x)) +(Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (SignExt32to64 (Trunc64to32 <fe.TypeInt32()> x)) // constant comparisons (Eq64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(c == d)]) @@ -754,8 +754,8 @@ // indexing operations // Note: bounds check has already been done -(PtrIndex <t> ptr idx) && config.PtrSize == 4 -> (AddPtr ptr (Mul32 <config.fe.TypeInt()> idx (Const32 <config.fe.TypeInt()> [t.ElemType().Size()]))) -(PtrIndex <t> ptr idx) && config.PtrSize == 8 -> (AddPtr ptr (Mul64 <config.fe.TypeInt()> idx (Const64 <config.fe.TypeInt()> [t.ElemType().Size()]))) +(PtrIndex <t> ptr idx) && config.PtrSize == 4 -> (AddPtr ptr (Mul32 <fe.TypeInt()> idx (Const32 <fe.TypeInt()> [t.ElemType().Size()]))) +(PtrIndex <t> ptr idx) && config.PtrSize == 8 -> (AddPtr ptr (Mul64 <fe.TypeInt()> idx (Const64 <fe.TypeInt()> [t.ElemType().Size()]))) // struct operations (StructSelect (StructMake1 x)) -> x @@ -769,28 +769,28 @@ (StructSelect [2] (StructMake4 _ _ x _)) -> x (StructSelect [3] (StructMake4 _ _ _ x)) -> x -(Load <t> _ _) && t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) -> +(Load <t> _ _) && t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) -> (StructMake0) -(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) -> +(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) -> (StructMake1 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem)) -(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) -> +(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t) -> (StructMake2 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem)) -(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) -> +(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t) -> (StructMake3 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem)) -(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) -> +(Load <t> ptr mem) && t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t) -> (StructMake4 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem) (Load <t.FieldType(3)> (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] ptr) mem)) -(StructSelect [i] x:(Load <t> ptr mem)) && !config.fe.CanSSA(t) -> +(StructSelect [i] x:(Load <t> ptr mem)) && !fe.CanSSA(t) -> @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem) (Store _ (StructMake0) mem) -> mem @@ -832,9 +832,9 @@ (StructSelect [0] x:(IData _)) -> x // un-SSAable values use mem->mem copies -(Store {t} dst (Load src mem) mem) && !config.fe.CanSSA(t.(Type)) -> +(Store {t} dst (Load src mem) mem) && !fe.CanSSA(t.(Type)) -> (Move {t} [t.(Type).Size()] dst src mem) -(Store {t} dst (Load src mem) (VarDef {x} mem)) && !config.fe.CanSSA(t.(Type)) -> +(Store {t} dst (Load src mem) (VarDef {x} mem)) && !fe.CanSSA(t.(Type)) -> (Move {t} [t.(Type).Size()] dst src (VarDef {x} mem)) // array ops @@ -843,7 +843,7 @@ (Load <t> _ _) && t.IsArray() && t.NumElem() == 0 -> (ArrayMake0) -(Load <t> ptr mem) && t.IsArray() && t.NumElem() == 1 && config.fe.CanSSA(t) -> +(Load <t> ptr mem) && t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t) -> (ArrayMake1 (Load <t.ElemType()> ptr mem)) (Store _ (ArrayMake0) mem) -> mem @@ -862,19 +862,19 @@ (StringPtr (StringMake (Const64 <t> [c]) _)) -> (Const64 <t> [c]) (StringLen (StringMake _ (Const64 <t> [c]))) -> (Const64 <t> [c]) (ConstString {s}) && config.PtrSize == 4 && s.(string) == "" -> - (StringMake (ConstNil) (Const32 <config.fe.TypeInt()> [0])) + (StringMake (ConstNil) (Const32 <fe.TypeInt()> [0])) (ConstString {s}) && config.PtrSize == 8 && s.(string) == "" -> - (StringMake (ConstNil) (Const64 <config.fe.TypeInt()> [0])) + (StringMake (ConstNil) (Const64 <fe.TypeInt()> [0])) (ConstString {s}) && config.PtrSize == 4 && s.(string) != "" -> (StringMake - (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))} + (Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))} (SB)) - (Const32 <config.fe.TypeInt()> [int64(len(s.(string)))])) + (Const32 <fe.TypeInt()> [int64(len(s.(string)))])) (ConstString {s}) && config.PtrSize == 8 && s.(string) != "" -> (StringMake - (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))} + (Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))} (SB)) - (Const64 <config.fe.TypeInt()> [int64(len(s.(string)))])) + (Const64 <fe.TypeInt()> [int64(len(s.(string)))])) // slice ops // Only a few slice rules are provided here. See dec.rules for @@ -890,19 +890,19 @@ (ConstSlice) && config.PtrSize == 4 -> (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) - (Const32 <config.fe.TypeInt()> [0]) - (Const32 <config.fe.TypeInt()> [0])) + (Const32 <fe.TypeInt()> [0]) + (Const32 <fe.TypeInt()> [0])) (ConstSlice) && config.PtrSize == 8 -> (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) - (Const64 <config.fe.TypeInt()> [0]) - (Const64 <config.fe.TypeInt()> [0])) + (Const64 <fe.TypeInt()> [0]) + (Const64 <fe.TypeInt()> [0])) // interface ops (ConstInterface) -> (IMake - (ConstNil <config.fe.TypeBytePtr()>) - (ConstNil <config.fe.TypeBytePtr()>)) + (ConstNil <fe.TypeBytePtr()>) + (ConstNil <fe.TypeBytePtr()>)) (NilCheck (GetG mem) mem) -> mem @@ -918,45 +918,45 @@ // Decompose compound argument values (Arg {n} [off]) && v.Type.IsString() -> (StringMake - (Arg <config.fe.TypeBytePtr()> {n} [off]) - (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize])) + (Arg <fe.TypeBytePtr()> {n} [off]) + (Arg <fe.TypeInt()> {n} [off+config.PtrSize])) (Arg {n} [off]) && v.Type.IsSlice() -> (SliceMake (Arg <v.Type.ElemType().PtrTo()> {n} [off]) - (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize]) - (Arg <config.fe.TypeInt()> {n} [off+2*config.PtrSize])) + (Arg <fe.TypeInt()> {n} [off+config.PtrSize]) + (Arg <fe.TypeInt()> {n} [off+2*config.PtrSize])) (Arg {n} [off]) && v.Type.IsInterface() -> (IMake - (Arg <config.fe.TypeBytePtr()> {n} [off]) - (Arg <config.fe.TypeBytePtr()> {n} [off+config.PtrSize])) + (Arg <fe.TypeBytePtr()> {n} [off]) + (Arg <fe.TypeBytePtr()> {n} [off+config.PtrSize])) (Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 16 -> (ComplexMake - (Arg <config.fe.TypeFloat64()> {n} [off]) - (Arg <config.fe.TypeFloat64()> {n} [off+8])) + (Arg <fe.TypeFloat64()> {n} [off]) + (Arg <fe.TypeFloat64()> {n} [off+8])) (Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 8 -> (ComplexMake - (Arg <config.fe.TypeFloat32()> {n} [off]) - (Arg <config.fe.TypeFloat32()> {n} [off+4])) + (Arg <fe.TypeFloat32()> {n} [off]) + (Arg <fe.TypeFloat32()> {n} [off+4])) -(Arg <t>) && t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) -> +(Arg <t>) && t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) -> (StructMake0) -(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) -> +(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) -> (StructMake1 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)])) -(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) -> +(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t) -> (StructMake2 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)])) -(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) -> +(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t) -> (StructMake3 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)])) -(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) -> +(Arg <t> {n} [off]) && t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t) -> (StructMake4 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) @@ -965,132 +965,132 @@ (Arg <t>) && t.IsArray() && t.NumElem() == 0 -> (ArrayMake0) -(Arg <t> {n} [off]) && t.IsArray() && t.NumElem() == 1 && config.fe.CanSSA(t) -> +(Arg <t> {n} [off]) && t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t) -> (ArrayMake1 (Arg <t.ElemType()> {n} [off])) // strength reduction of divide by a constant. // See ../magic.go for a detailed description of these algorithms. // Unsigned divide by power of 2. Strength reduce to a shift. -(Div8u n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (Rsh8Ux64 n (Const64 <config.fe.TypeUInt64()> [log2(c&0xff)])) -(Div16u n (Const16 [c])) && isPowerOfTwo(c&0xffff) -> (Rsh16Ux64 n (Const64 <config.fe.TypeUInt64()> [log2(c&0xffff)])) -(Div32u n (Const32 [c])) && isPowerOfTwo(c&0xffffffff) -> (Rsh32Ux64 n (Const64 <config.fe.TypeUInt64()> [log2(c&0xffffffff)])) -(Div64u n (Const64 [c])) && isPowerOfTwo(c) -> (Rsh64Ux64 n (Const64 <config.fe.TypeUInt64()> [log2(c)])) +(Div8u n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (Rsh8Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xff)])) +(Div16u n (Const16 [c])) && isPowerOfTwo(c&0xffff) -> (Rsh16Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffff)])) +(Div32u n (Const32 [c])) && isPowerOfTwo(c&0xffffffff) -> (Rsh32Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffffffff)])) +(Div64u n (Const64 [c])) && isPowerOfTwo(c) -> (Rsh64Ux64 n (Const64 <fe.TypeUInt64()> [log2(c)])) // Unsigned divide, not a power of 2. Strength reduce to a multiply. // For 8-bit divides, we just do a direct 9-bit by 8-bit multiply. (Div8u x (Const8 [c])) && umagicOK(8, c) -> (Trunc32to8 - (Rsh32Ux64 <config.fe.TypeUInt32()> - (Mul32 <config.fe.TypeUInt32()> - (Const32 <config.fe.TypeUInt32()> [int64(1<<8+umagic(8,c).m)]) + (Rsh32Ux64 <fe.TypeUInt32()> + (Mul32 <fe.TypeUInt32()> + (Const32 <fe.TypeUInt32()> [int64(1<<8+umagic(8,c).m)]) (ZeroExt8to32 x)) - (Const64 <config.fe.TypeUInt64()> [8+umagic(8,c).s]))) + (Const64 <fe.TypeUInt64()> [8+umagic(8,c).s]))) // For 16-bit divides on 64-bit machines, we do a direct 17-bit by 16-bit multiply. (Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 8 -> (Trunc64to16 - (Rsh64Ux64 <config.fe.TypeUInt64()> - (Mul64 <config.fe.TypeUInt64()> - (Const64 <config.fe.TypeUInt64()> [int64(1<<16+umagic(16,c).m)]) + (Rsh64Ux64 <fe.TypeUInt64()> + (Mul64 <fe.TypeUInt64()> + (Const64 <fe.TypeUInt64()> [int64(1<<16+umagic(16,c).m)]) (ZeroExt16to64 x)) - (Const64 <config.fe.TypeUInt64()> [16+umagic(16,c).s]))) + (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s]))) // For 16-bit divides on 32-bit machines (Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0 -> (Trunc32to16 - (Rsh32Ux64 <config.fe.TypeUInt32()> - (Mul32 <config.fe.TypeUInt32()> - (Const32 <config.fe.TypeUInt32()> [int64(1<<15+umagic(16,c).m/2)]) + (Rsh32Ux64 <fe.TypeUInt32()> + (Mul32 <fe.TypeUInt32()> + (Const32 <fe.TypeUInt32()> [int64(1<<15+umagic(16,c).m/2)]) (ZeroExt16to32 x)) - (Const64 <config.fe.TypeUInt64()> [16+umagic(16,c).s-1]))) + (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1]))) (Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 && c&1 == 0 -> (Trunc32to16 - (Rsh32Ux64 <config.fe.TypeUInt32()> - (Mul32 <config.fe.TypeUInt32()> - (Const32 <config.fe.TypeUInt32()> [int64(1<<15+(umagic(16,c).m+1)/2)]) - (Rsh32Ux64 <config.fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <config.fe.TypeUInt64()> [1]))) - (Const64 <config.fe.TypeUInt64()> [16+umagic(16,c).s-2]))) + (Rsh32Ux64 <fe.TypeUInt32()> + (Mul32 <fe.TypeUInt32()> + (Const32 <fe.TypeUInt32()> [int64(1<<15+(umagic(16,c).m+1)/2)]) + (Rsh32Ux64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [1]))) + (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-2]))) (Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 -> (Trunc32to16 - (Rsh32Ux64 <config.fe.TypeUInt32()> + (Rsh32Ux64 <fe.TypeUInt32()> (Avg32u - (Lsh32x64 <config.fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <config.fe.TypeUInt64()> [16])) - (Mul32 <config.fe.TypeUInt32()> - (Const32 <config.fe.TypeUInt32()> [int64(umagic(16,c).m)]) + (Lsh32x64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [16])) + (Mul32 <fe.TypeUInt32()> + (Const32 <fe.TypeUInt32()> [int64(umagic(16,c).m)]) (ZeroExt16to32 x))) - (Const64 <config.fe.TypeUInt64()> [16+umagic(16,c).s-1]))) + (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1]))) // For 32-bit divides on 32-bit machines (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 -> - (Rsh32Ux64 <config.fe.TypeUInt32()> - (Hmul32u <config.fe.TypeUInt32()> - (Const32 <config.fe.TypeUInt32()> [int64(int32(1<<31+umagic(32,c).m/2))]) + (Rsh32Ux64 <fe.TypeUInt32()> + (Hmul32u <fe.TypeUInt32()> + (Const32 <fe.TypeUInt32()> [int64(int32(1<<31+umagic(32,c).m/2))]) x) - (Const64 <config.fe.TypeUInt64()> [umagic(32,c).s-1])) + (Const64 <fe.TypeUInt64()> [umagic(32,c).s-1])) (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 -> - (Rsh32Ux64 <config.fe.TypeUInt32()> - (Hmul32u <config.fe.TypeUInt32()> - (Const32 <config.fe.TypeUInt32()> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) - (Rsh32Ux64 <config.fe.TypeUInt32()> x (Const64 <config.fe.TypeUInt64()> [1]))) - (Const64 <config.fe.TypeUInt64()> [umagic(32,c).s-2])) + (Rsh32Ux64 <fe.TypeUInt32()> + (Hmul32u <fe.TypeUInt32()> + (Const32 <fe.TypeUInt32()> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) + (Rsh32Ux64 <fe.TypeUInt32()> x (Const64 <fe.TypeUInt64()> [1]))) + (Const64 <fe.TypeUInt64()> [umagic(32,c).s-2])) (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 -> - (Rsh32Ux64 <config.fe.TypeUInt32()> + (Rsh32Ux64 <fe.TypeUInt32()> (Avg32u x - (Hmul32u <config.fe.TypeUInt32()> - (Const32 <config.fe.TypeUInt32()> [int64(int32(umagic(32,c).m))]) + (Hmul32u <fe.TypeUInt32()> + (Const32 <fe.TypeUInt32()> [int64(int32(umagic(32,c).m))]) x)) - (Const64 <config.fe.TypeUInt64()> [umagic(32,c).s-1])) + (Const64 <fe.TypeUInt64()> [umagic(32,c).s-1])) // For 32-bit divides on 64-bit machines // We'll use a regular (non-hi) multiply for this case. (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0 -> (Trunc64to32 - (Rsh64Ux64 <config.fe.TypeUInt64()> - (Mul64 <config.fe.TypeUInt64()> - (Const64 <config.fe.TypeUInt64()> [int64(1<<31+umagic(32,c).m/2)]) + (Rsh64Ux64 <fe.TypeUInt64()> + (Mul64 <fe.TypeUInt64()> + (Const64 <fe.TypeUInt64()> [int64(1<<31+umagic(32,c).m/2)]) (ZeroExt32to64 x)) - (Const64 <config.fe.TypeUInt64()> [32+umagic(32,c).s-1]))) + (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1]))) (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 && c&1 == 0 -> (Trunc64to32 - (Rsh64Ux64 <config.fe.TypeUInt64()> - (Mul64 <config.fe.TypeUInt64()> - (Const64 <config.fe.TypeUInt64()> [int64(1<<31+(umagic(32,c).m+1)/2)]) - (Rsh64Ux64 <config.fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <config.fe.TypeUInt64()> [1]))) - (Const64 <config.fe.TypeUInt64()> [32+umagic(32,c).s-2]))) + (Rsh64Ux64 <fe.TypeUInt64()> + (Mul64 <fe.TypeUInt64()> + (Const64 <fe.TypeUInt64()> [int64(1<<31+(umagic(32,c).m+1)/2)]) + (Rsh64Ux64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [1]))) + (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-2]))) (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 -> (Trunc64to32 - (Rsh64Ux64 <config.fe.TypeUInt64()> + (Rsh64Ux64 <fe.TypeUInt64()> (Avg64u - (Lsh64x64 <config.fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <config.fe.TypeUInt64()> [32])) - (Mul64 <config.fe.TypeUInt64()> - (Const64 <config.fe.TypeUInt32()> [int64(umagic(32,c).m)]) + (Lsh64x64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [32])) + (Mul64 <fe.TypeUInt64()> + (Const64 <fe.TypeUInt32()> [int64(umagic(32,c).m)]) (ZeroExt32to64 x))) - (Const64 <config.fe.TypeUInt64()> [32+umagic(32,c).s-1]))) + (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1]))) // For 64-bit divides on 64-bit machines // (64-bit divides on 32-bit machines are lowered to a runtime call by the walk pass.) (Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 -> - (Rsh64Ux64 <config.fe.TypeUInt64()> - (Hmul64u <config.fe.TypeUInt64()> - (Const64 <config.fe.TypeUInt64()> [int64(1<<63+umagic(64,c).m/2)]) + (Rsh64Ux64 <fe.TypeUInt64()> + (Hmul64u <fe.TypeUInt64()> + (Const64 <fe.TypeUInt64()> [int64(1<<63+umagic(64,c).m/2)]) x) - (Const64 <config.fe.TypeUInt64()> [umagic(64,c).s-1])) + (Const64 <fe.TypeUInt64()> [umagic(64,c).s-1])) (Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 -> - (Rsh64Ux64 <config.fe.TypeUInt64()> - (Hmul64u <config.fe.TypeUInt64()> - (Const64 <config.fe.TypeUInt64()> [int64(1<<63+(umagic(64,c).m+1)/2)]) - (Rsh64Ux64 <config.fe.TypeUInt64()> x (Const64 <config.fe.TypeUInt64()> [1]))) - (Const64 <config.fe.TypeUInt64()> [umagic(64,c).s-2])) + (Rsh64Ux64 <fe.TypeUInt64()> + (Hmul64u <fe.TypeUInt64()> + (Const64 <fe.TypeUInt64()> [int64(1<<63+(umagic(64,c).m+1)/2)]) + (Rsh64Ux64 <fe.TypeUInt64()> x (Const64 <fe.TypeUInt64()> [1]))) + (Const64 <fe.TypeUInt64()> [umagic(64,c).s-2])) (Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 -> - (Rsh64Ux64 <config.fe.TypeUInt64()> + (Rsh64Ux64 <fe.TypeUInt64()> (Avg64u x - (Hmul64u <config.fe.TypeUInt64()> - (Const64 <config.fe.TypeUInt64()> [int64(umagic(64,c).m)]) + (Hmul64u <fe.TypeUInt64()> + (Const64 <fe.TypeUInt64()> [int64(umagic(64,c).m)]) x)) - (Const64 <config.fe.TypeUInt64()> [umagic(64,c).s-1])) + (Const64 <fe.TypeUInt64()> [umagic(64,c).s-1])) // Signed divide by a negative constant. Rewrite to divide by a positive constant. (Div8 <t> n (Const8 [c])) && c < 0 && c != -1<<7 -> (Neg8 (Div8 <t> n (Const8 <t> [-c]))) @@ -1101,10 +1101,10 @@ // Dividing by the most-negative number. Result is always 0 except // if the input is also the most-negative number. // We can detect that using the sign bit of x & -x. -(Div8 <t> x (Const8 [-1<<7 ])) -> (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <config.fe.TypeUInt64()> [7 ])) -(Div16 <t> x (Const16 [-1<<15])) -> (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <config.fe.TypeUInt64()> [15])) -(Div32 <t> x (Const32 [-1<<31])) -> (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <config.fe.TypeUInt64()> [31])) -(Div64 <t> x (Const64 [-1<<63])) -> (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <config.fe.TypeUInt64()> [63])) +(Div8 <t> x (Const8 [-1<<7 ])) -> (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <fe.TypeUInt64()> [7 ])) +(Div16 <t> x (Const16 [-1<<15])) -> (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <fe.TypeUInt64()> [15])) +(Div32 <t> x (Const32 [-1<<31])) -> (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <fe.TypeUInt64()> [31])) +(Div64 <t> x (Const64 [-1<<63])) -> (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <fe.TypeUInt64()> [63])) // Signed divide by power of 2. // n / c = n >> log(c) if n >= 0 @@ -1112,96 +1112,96 @@ // We conditionally add c-1 by adding n>>63>>(64-log(c)) (first shift signed, second shift unsigned). (Div8 <t> n (Const8 [c])) && isPowerOfTwo(c) -> (Rsh8x64 - (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <config.fe.TypeUInt64()> [ 7])) (Const64 <config.fe.TypeUInt64()> [ 8-log2(c)]))) - (Const64 <config.fe.TypeUInt64()> [log2(c)])) + (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <fe.TypeUInt64()> [ 7])) (Const64 <fe.TypeUInt64()> [ 8-log2(c)]))) + (Const64 <fe.TypeUInt64()> [log2(c)])) (Div16 <t> n (Const16 [c])) && isPowerOfTwo(c) -> (Rsh16x64 - (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <config.fe.TypeUInt64()> [15])) (Const64 <config.fe.TypeUInt64()> [16-log2(c)]))) - (Const64 <config.fe.TypeUInt64()> [log2(c)])) + (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <fe.TypeUInt64()> [15])) (Const64 <fe.TypeUInt64()> [16-log2(c)]))) + (Const64 <fe.TypeUInt64()> [log2(c)])) (Div32 <t> n (Const32 [c])) && isPowerOfTwo(c) -> (Rsh32x64 - (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <config.fe.TypeUInt64()> [31])) (Const64 <config.fe.TypeUInt64()> [32-log2(c)]))) - (Const64 <config.fe.TypeUInt64()> [log2(c)])) + (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <fe.TypeUInt64()> [31])) (Const64 <fe.TypeUInt64()> [32-log2(c)]))) + (Const64 <fe.TypeUInt64()> [log2(c)])) (Div64 <t> n (Const64 [c])) && isPowerOfTwo(c) -> (Rsh64x64 - (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <config.fe.TypeUInt64()> [63])) (Const64 <config.fe.TypeUInt64()> [64-log2(c)]))) - (Const64 <config.fe.TypeUInt64()> [log2(c)])) + (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <fe.TypeUInt64()> [63])) (Const64 <fe.TypeUInt64()> [64-log2(c)]))) + (Const64 <fe.TypeUInt64()> [log2(c)])) // Signed divide, not a power of 2. Strength reduce to a multiply. (Div8 <t> x (Const8 [c])) && smagicOK(8,c) -> (Sub8 <t> (Rsh32x64 <t> - (Mul32 <config.fe.TypeUInt32()> - (Const32 <config.fe.TypeUInt32()> [int64(smagic(8,c).m)]) + (Mul32 <fe.TypeUInt32()> + (Const32 <fe.TypeUInt32()> [int64(smagic(8,c).m)]) (SignExt8to32 x)) - (Const64 <config.fe.TypeUInt64()> [8+smagic(8,c).s])) + (Const64 <fe.TypeUInt64()> [8+smagic(8,c).s])) (Rsh32x64 <t> (SignExt8to32 x) - (Const64 <config.fe.TypeUInt64()> [31]))) + (Const64 <fe.TypeUInt64()> [31]))) (Div16 <t> x (Const16 [c])) && smagicOK(16,c) -> (Sub16 <t> (Rsh32x64 <t> - (Mul32 <config.fe.TypeUInt32()> - (Const32 <config.fe.TypeUInt32()> [int64(smagic(16,c).m)]) + (Mul32 <fe.TypeUInt32()> + (Const32 <fe.TypeUInt32()> [int64(smagic(16,c).m)]) (SignExt16to32 x)) - (Const64 <config.fe.TypeUInt64()> [16+smagic(16,c).s])) + (Const64 <fe.TypeUInt64()> [16+smagic(16,c).s])) (Rsh32x64 <t> (SignExt16to32 x) - (Const64 <config.fe.TypeUInt64()> [31]))) + (Const64 <fe.TypeUInt64()> [31]))) (Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 8 -> (Sub32 <t> (Rsh64x64 <t> - (Mul64 <config.fe.TypeUInt64()> - (Const64 <config.fe.TypeUInt64()> [int64(smagic(32,c).m)]) + (Mul64 <fe.TypeUInt64()> + (Const64 <fe.TypeUInt64()> [int64(smagic(32,c).m)]) (SignExt32to64 x)) - (Const64 <config.fe.TypeUInt64()> [32+smagic(32,c).s])) + (Const64 <fe.TypeUInt64()> [32+smagic(32,c).s])) (Rsh64x64 <t> (SignExt32to64 x) - (Const64 <config.fe.TypeUInt64()> [63]))) + (Const64 <fe.TypeUInt64()> [63]))) (Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 -> (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> - (Const32 <config.fe.TypeUInt32()> [int64(int32(smagic(32,c).m/2))]) + (Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m/2))]) x) - (Const64 <config.fe.TypeUInt64()> [smagic(32,c).s-1])) + (Const64 <fe.TypeUInt64()> [smagic(32,c).s-1])) (Rsh32x64 <t> x - (Const64 <config.fe.TypeUInt64()> [31]))) + (Const64 <fe.TypeUInt64()> [31]))) (Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 -> (Sub32 <t> (Rsh32x64 <t> (Add32 <t> (Hmul32 <t> - (Const32 <config.fe.TypeUInt32()> [int64(int32(smagic(32,c).m))]) + (Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m))]) x) x) - (Const64 <config.fe.TypeUInt64()> [smagic(32,c).s])) + (Const64 <fe.TypeUInt64()> [smagic(32,c).s])) (Rsh32x64 <t> x - (Const64 <config.fe.TypeUInt64()> [31]))) + (Const64 <fe.TypeUInt64()> [31]))) (Div64 <t> x (Const64 [c])) && smagicOK(64,c) && smagic(64,c).m&1 == 0 -> (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> - (Const64 <config.fe.TypeUInt64()> [int64(smagic(64,c).m/2)]) + (Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m/2)]) x) - (Const64 <config.fe.TypeUInt64()> [smagic(64,c).s-1])) + (Const64 <fe.TypeUInt64()> [smagic(64,c).s-1])) (Rsh64x64 <t> x - (Const64 <config.fe.TypeUInt64()> [63]))) + (Const64 <fe.TypeUInt64()> [63]))) (Div64 <t> x (Const64 [c])) && smagicOK(64,c) && smagic(64,c).m&1 != 0 -> (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> - (Const64 <config.fe.TypeUInt64()> [int64(smagic(64,c).m)]) + (Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m)]) x) x) - (Const64 <config.fe.TypeUInt64()> [smagic(64,c).s])) + (Const64 <fe.TypeUInt64()> [smagic(64,c).s])) (Rsh64x64 <t> x - (Const64 <config.fe.TypeUInt64()> [63]))) + (Const64 <fe.TypeUInt64()> [63]))) // Unsigned mod by power of 2 constant. (Mod8u <t> n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (And8 n (Const8 <t> [(c&0xff)-1])) @@ -1423,13 +1423,13 @@ && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value - && warnRule(config.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") + && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") -> (Invalid) (NilCheck (OffPtr (Load (OffPtr [c] (SP)) mem)) mem) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value - && warnRule(config.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") + && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") -> (Invalid) // De-virtualize interface calls into static calls. diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 3b6e3a98f7..e6ca5c4f02 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -156,11 +156,11 @@ func genRules(arch arch) { fmt.Fprintln(w, "var _ = math.MinInt8 // in case not otherwise used") // Main rewrite routine is a switch on v.Op. - fmt.Fprintf(w, "func rewriteValue%s(v *Value, config *Config) bool {\n", arch.name) + fmt.Fprintf(w, "func rewriteValue%s(v *Value) bool {\n", arch.name) fmt.Fprintf(w, "switch v.Op {\n") for _, op := range ops { fmt.Fprintf(w, "case %s:\n", op) - fmt.Fprintf(w, "return rewriteValue%s_%s(v, config)\n", arch.name, op) + fmt.Fprintf(w, "return rewriteValue%s_%s(v)\n", arch.name, op) } fmt.Fprintf(w, "}\n") fmt.Fprintf(w, "return false\n") @@ -169,47 +169,71 @@ func genRules(arch arch) { // Generate a routine per op. Note that we don't make one giant routine // because it is too big for some compilers. for _, op := range ops { - fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value, config *Config) bool {\n", arch.name, op) - fmt.Fprintln(w, "b := v.Block") - fmt.Fprintln(w, "_ = b") + buf := new(bytes.Buffer) var canFail bool for i, rule := range oprules[op] { match, cond, result := rule.parse() - fmt.Fprintf(w, "// match: %s\n", match) - fmt.Fprintf(w, "// cond: %s\n", cond) - fmt.Fprintf(w, "// result: %s\n", result) + fmt.Fprintf(buf, "// match: %s\n", match) + fmt.Fprintf(buf, "// cond: %s\n", cond) + fmt.Fprintf(buf, "// result: %s\n", result) canFail = false - fmt.Fprintf(w, "for {\n") - if genMatch(w, arch, match, rule.loc) { + fmt.Fprintf(buf, "for {\n") + if genMatch(buf, arch, match, rule.loc) { canFail = true } if cond != "" { - fmt.Fprintf(w, "if !(%s) {\nbreak\n}\n", cond) + fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond) canFail = true } if !canFail && i != len(oprules[op])-1 { log.Fatalf("unconditional rule %s is followed by other rules", match) } - genResult(w, arch, result, rule.loc) + genResult(buf, arch, result, rule.loc) if *genLog { - fmt.Fprintf(w, "logRule(\"%s\")\n", rule.loc) + fmt.Fprintf(buf, "logRule(\"%s\")\n", rule.loc) } - fmt.Fprintf(w, "return true\n") + fmt.Fprintf(buf, "return true\n") - fmt.Fprintf(w, "}\n") + fmt.Fprintf(buf, "}\n") } if canFail { - fmt.Fprintf(w, "return false\n") - } + fmt.Fprintf(buf, "return false\n") + } + + body := buf.String() + // Do a rough match to predict whether we need b, config, and/or fe. + // It's not precise--thus the blank assignments--but it's good enough + // to avoid generating needless code and doing pointless nil checks. + hasb := strings.Contains(body, "b.") + hasconfig := strings.Contains(body, "config.") + hasfe := strings.Contains(body, "fe.") + fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value) bool {\n", arch.name, op) + if hasb || hasconfig || hasfe { + fmt.Fprintln(w, "b := v.Block") + fmt.Fprintln(w, "_ = b") + } + if hasconfig || hasfe { + fmt.Fprintln(w, "config := b.Func.Config") + fmt.Fprintln(w, "_ = config") + } + if hasfe { + fmt.Fprintln(w, "fe := config.fe") + fmt.Fprintln(w, "_ = fe") + } + fmt.Fprint(w, body) fmt.Fprintf(w, "}\n") } // Generate block rewrite function. There are only a few block types // so we can make this one function with a switch. - fmt.Fprintf(w, "func rewriteBlock%s(b *Block, config *Config) bool {\n", arch.name) + fmt.Fprintf(w, "func rewriteBlock%s(b *Block) bool {\n", arch.name) + fmt.Fprintln(w, "config := b.Func.Config") + fmt.Fprintln(w, "_ = config") + fmt.Fprintln(w, "fe := config.fe") + fmt.Fprintln(w, "_ = fe") fmt.Fprintf(w, "switch b.Kind {\n") ops = nil for op := range blockrules { @@ -695,7 +719,7 @@ func typeName(typ string) string { case "Flags", "Mem", "Void", "Int128": return "Type" + typ default: - return "config.fe.Type" + typ + "()" + return "fe.Type" + typ + "()" } } diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 26c6518eeb..68bd0ad66c 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -14,7 +14,7 @@ import ( "strings" ) -func applyRewrite(f *Func, rb func(*Block, *Config) bool, rv func(*Value, *Config) bool) { +func applyRewrite(f *Func, rb blockRewriter, rv valueRewriter) { // repeat rewrites until we find no more rewrites var curb *Block var curv *Value @@ -27,7 +27,6 @@ func applyRewrite(f *Func, rb func(*Block, *Config) bool, rv func(*Value, *Confi // TODO(khr): print source location also } }() - config := f.Config for { change := false for _, b := range f.Blocks { @@ -37,7 +36,7 @@ func applyRewrite(f *Func, rb func(*Block, *Config) bool, rv func(*Value, *Confi } } curb = b - if rb(b, config) { + if rb(b) { change = true } curb = nil @@ -66,7 +65,7 @@ func applyRewrite(f *Func, rb func(*Block, *Config) bool, rv func(*Value, *Confi // apply rewrite function curv = v - if rv(v, config) { + if rv(v) { change = true } curv = nil diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go index 0e7c54b89f..2d0eda6e50 100644 --- a/src/cmd/compile/internal/ssa/rewrite386.go +++ b/src/cmd/compile/internal/ssa/rewrite386.go @@ -6,588 +6,586 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValue386(v *Value, config *Config) bool { +func rewriteValue386(v *Value) bool { switch v.Op { case Op386ADCL: - return rewriteValue386_Op386ADCL(v, config) + return rewriteValue386_Op386ADCL(v) case Op386ADDL: - return rewriteValue386_Op386ADDL(v, config) + return rewriteValue386_Op386ADDL(v) case Op386ADDLcarry: - return rewriteValue386_Op386ADDLcarry(v, config) + return rewriteValue386_Op386ADDLcarry(v) case Op386ADDLconst: - return rewriteValue386_Op386ADDLconst(v, config) + return rewriteValue386_Op386ADDLconst(v) case Op386ANDL: - return rewriteValue386_Op386ANDL(v, config) + return rewriteValue386_Op386ANDL(v) case Op386ANDLconst: - return rewriteValue386_Op386ANDLconst(v, config) + return rewriteValue386_Op386ANDLconst(v) case Op386CMPB: - return rewriteValue386_Op386CMPB(v, config) + return rewriteValue386_Op386CMPB(v) case Op386CMPBconst: - return rewriteValue386_Op386CMPBconst(v, config) + return rewriteValue386_Op386CMPBconst(v) case Op386CMPL: - return rewriteValue386_Op386CMPL(v, config) + return rewriteValue386_Op386CMPL(v) case Op386CMPLconst: - return rewriteValue386_Op386CMPLconst(v, config) + return rewriteValue386_Op386CMPLconst(v) case Op386CMPW: - return rewriteValue386_Op386CMPW(v, config) + return rewriteValue386_Op386CMPW(v) case Op386CMPWconst: - return rewriteValue386_Op386CMPWconst(v, config) + return rewriteValue386_Op386CMPWconst(v) case Op386LEAL: - return rewriteValue386_Op386LEAL(v, config) + return rewriteValue386_Op386LEAL(v) case Op386LEAL1: - return rewriteValue386_Op386LEAL1(v, config) + return rewriteValue386_Op386LEAL1(v) case Op386LEAL2: - return rewriteValue386_Op386LEAL2(v, config) + return rewriteValue386_Op386LEAL2(v) case Op386LEAL4: - return rewriteValue386_Op386LEAL4(v, config) + return rewriteValue386_Op386LEAL4(v) case Op386LEAL8: - return rewriteValue386_Op386LEAL8(v, config) + return rewriteValue386_Op386LEAL8(v) case Op386MOVBLSX: - return rewriteValue386_Op386MOVBLSX(v, config) + return rewriteValue386_Op386MOVBLSX(v) case Op386MOVBLSXload: - return rewriteValue386_Op386MOVBLSXload(v, config) + return rewriteValue386_Op386MOVBLSXload(v) case Op386MOVBLZX: - return rewriteValue386_Op386MOVBLZX(v, config) + return rewriteValue386_Op386MOVBLZX(v) case Op386MOVBload: - return rewriteValue386_Op386MOVBload(v, config) + return rewriteValue386_Op386MOVBload(v) case Op386MOVBloadidx1: - return rewriteValue386_Op386MOVBloadidx1(v, config) + return rewriteValue386_Op386MOVBloadidx1(v) case Op386MOVBstore: - return rewriteValue386_Op386MOVBstore(v, config) + return rewriteValue386_Op386MOVBstore(v) case Op386MOVBstoreconst: - return rewriteValue386_Op386MOVBstoreconst(v, config) + return rewriteValue386_Op386MOVBstoreconst(v) case Op386MOVBstoreconstidx1: - return rewriteValue386_Op386MOVBstoreconstidx1(v, config) + return rewriteValue386_Op386MOVBstoreconstidx1(v) case Op386MOVBstoreidx1: - return rewriteValue386_Op386MOVBstoreidx1(v, config) + return rewriteValue386_Op386MOVBstoreidx1(v) case Op386MOVLload: - return rewriteValue386_Op386MOVLload(v, config) + return rewriteValue386_Op386MOVLload(v) case Op386MOVLloadidx1: - return rewriteValue386_Op386MOVLloadidx1(v, config) + return rewriteValue386_Op386MOVLloadidx1(v) case Op386MOVLloadidx4: - return rewriteValue386_Op386MOVLloadidx4(v, config) + return rewriteValue386_Op386MOVLloadidx4(v) case Op386MOVLstore: - return rewriteValue386_Op386MOVLstore(v, config) + return rewriteValue386_Op386MOVLstore(v) case Op386MOVLstoreconst: - return rewriteValue386_Op386MOVLstoreconst(v, config) + return rewriteValue386_Op386MOVLstoreconst(v) case Op386MOVLstoreconstidx1: - return rewriteValue386_Op386MOVLstoreconstidx1(v, config) + return rewriteValue386_Op386MOVLstoreconstidx1(v) case Op386MOVLstoreconstidx4: - return rewriteValue386_Op386MOVLstoreconstidx4(v, config) + return rewriteValue386_Op386MOVLstoreconstidx4(v) case Op386MOVLstoreidx1: - return rewriteValue386_Op386MOVLstoreidx1(v, config) + return rewriteValue386_Op386MOVLstoreidx1(v) case Op386MOVLstoreidx4: - return rewriteValue386_Op386MOVLstoreidx4(v, config) + return rewriteValue386_Op386MOVLstoreidx4(v) case Op386MOVSDconst: - return rewriteValue386_Op386MOVSDconst(v, config) + return rewriteValue386_Op386MOVSDconst(v) case Op386MOVSDload: - return rewriteValue386_Op386MOVSDload(v, config) + return rewriteValue386_Op386MOVSDload(v) case Op386MOVSDloadidx1: - return rewriteValue386_Op386MOVSDloadidx1(v, config) + return rewriteValue386_Op386MOVSDloadidx1(v) case Op386MOVSDloadidx8: - return rewriteValue386_Op386MOVSDloadidx8(v, config) + return rewriteValue386_Op386MOVSDloadidx8(v) case Op386MOVSDstore: - return rewriteValue386_Op386MOVSDstore(v, config) + return rewriteValue386_Op386MOVSDstore(v) case Op386MOVSDstoreidx1: - return rewriteValue386_Op386MOVSDstoreidx1(v, config) + return rewriteValue386_Op386MOVSDstoreidx1(v) case Op386MOVSDstoreidx8: - return rewriteValue386_Op386MOVSDstoreidx8(v, config) + return rewriteValue386_Op386MOVSDstoreidx8(v) case Op386MOVSSconst: - return rewriteValue386_Op386MOVSSconst(v, config) + return rewriteValue386_Op386MOVSSconst(v) case Op386MOVSSload: - return rewriteValue386_Op386MOVSSload(v, config) + return rewriteValue386_Op386MOVSSload(v) case Op386MOVSSloadidx1: - return rewriteValue386_Op386MOVSSloadidx1(v, config) + return rewriteValue386_Op386MOVSSloadidx1(v) case Op386MOVSSloadidx4: - return rewriteValue386_Op386MOVSSloadidx4(v, config) + return rewriteValue386_Op386MOVSSloadidx4(v) case Op386MOVSSstore: - return rewriteValue386_Op386MOVSSstore(v, config) + return rewriteValue386_Op386MOVSSstore(v) case Op386MOVSSstoreidx1: - return rewriteValue386_Op386MOVSSstoreidx1(v, config) + return rewriteValue386_Op386MOVSSstoreidx1(v) case Op386MOVSSstoreidx4: - return rewriteValue386_Op386MOVSSstoreidx4(v, config) + return rewriteValue386_Op386MOVSSstoreidx4(v) case Op386MOVWLSX: - return rewriteValue386_Op386MOVWLSX(v, config) + return rewriteValue386_Op386MOVWLSX(v) case Op386MOVWLSXload: - return rewriteValue386_Op386MOVWLSXload(v, config) + return rewriteValue386_Op386MOVWLSXload(v) case Op386MOVWLZX: - return rewriteValue386_Op386MOVWLZX(v, config) + return rewriteValue386_Op386MOVWLZX(v) case Op386MOVWload: - return rewriteValue386_Op386MOVWload(v, config) + return rewriteValue386_Op386MOVWload(v) case Op386MOVWloadidx1: - return rewriteValue386_Op386MOVWloadidx1(v, config) + return rewriteValue386_Op386MOVWloadidx1(v) case Op386MOVWloadidx2: - return rewriteValue386_Op386MOVWloadidx2(v, config) + return rewriteValue386_Op386MOVWloadidx2(v) case Op386MOVWstore: - return rewriteValue386_Op386MOVWstore(v, config) + return rewriteValue386_Op386MOVWstore(v) case Op386MOVWstoreconst: - return rewriteValue386_Op386MOVWstoreconst(v, config) + return rewriteValue386_Op386MOVWstoreconst(v) case Op386MOVWstoreconstidx1: - return rewriteValue386_Op386MOVWstoreconstidx1(v, config) + return rewriteValue386_Op386MOVWstoreconstidx1(v) case Op386MOVWstoreconstidx2: - return rewriteValue386_Op386MOVWstoreconstidx2(v, config) + return rewriteValue386_Op386MOVWstoreconstidx2(v) case Op386MOVWstoreidx1: - return rewriteValue386_Op386MOVWstoreidx1(v, config) + return rewriteValue386_Op386MOVWstoreidx1(v) case Op386MOVWstoreidx2: - return rewriteValue386_Op386MOVWstoreidx2(v, config) + return rewriteValue386_Op386MOVWstoreidx2(v) case Op386MULL: - return rewriteValue386_Op386MULL(v, config) + return rewriteValue386_Op386MULL(v) case Op386MULLconst: - return rewriteValue386_Op386MULLconst(v, config) + return rewriteValue386_Op386MULLconst(v) case Op386NEGL: - return rewriteValue386_Op386NEGL(v, config) + return rewriteValue386_Op386NEGL(v) case Op386NOTL: - return rewriteValue386_Op386NOTL(v, config) + return rewriteValue386_Op386NOTL(v) case Op386ORL: - return rewriteValue386_Op386ORL(v, config) + return rewriteValue386_Op386ORL(v) case Op386ORLconst: - return rewriteValue386_Op386ORLconst(v, config) + return rewriteValue386_Op386ORLconst(v) case Op386ROLBconst: - return rewriteValue386_Op386ROLBconst(v, config) + return rewriteValue386_Op386ROLBconst(v) case Op386ROLLconst: - return rewriteValue386_Op386ROLLconst(v, config) + return rewriteValue386_Op386ROLLconst(v) case Op386ROLWconst: - return rewriteValue386_Op386ROLWconst(v, config) + return rewriteValue386_Op386ROLWconst(v) case Op386SARB: - return rewriteValue386_Op386SARB(v, config) + return rewriteValue386_Op386SARB(v) case Op386SARBconst: - return rewriteValue386_Op386SARBconst(v, config) + return rewriteValue386_Op386SARBconst(v) case Op386SARL: - return rewriteValue386_Op386SARL(v, config) + return rewriteValue386_Op386SARL(v) case Op386SARLconst: - return rewriteValue386_Op386SARLconst(v, config) + return rewriteValue386_Op386SARLconst(v) case Op386SARW: - return rewriteValue386_Op386SARW(v, config) + return rewriteValue386_Op386SARW(v) case Op386SARWconst: - return rewriteValue386_Op386SARWconst(v, config) + return rewriteValue386_Op386SARWconst(v) case Op386SBBL: - return rewriteValue386_Op386SBBL(v, config) + return rewriteValue386_Op386SBBL(v) case Op386SBBLcarrymask: - return rewriteValue386_Op386SBBLcarrymask(v, config) + return rewriteValue386_Op386SBBLcarrymask(v) case Op386SETA: - return rewriteValue386_Op386SETA(v, config) + return rewriteValue386_Op386SETA(v) case Op386SETAE: - return rewriteValue386_Op386SETAE(v, config) + return rewriteValue386_Op386SETAE(v) case Op386SETB: - return rewriteValue386_Op386SETB(v, config) + return rewriteValue386_Op386SETB(v) case Op386SETBE: - return rewriteValue386_Op386SETBE(v, config) + return rewriteValue386_Op386SETBE(v) case Op386SETEQ: - return rewriteValue386_Op386SETEQ(v, config) + return rewriteValue386_Op386SETEQ(v) case Op386SETG: - return rewriteValue386_Op386SETG(v, config) + return rewriteValue386_Op386SETG(v) case Op386SETGE: - return rewriteValue386_Op386SETGE(v, config) + return rewriteValue386_Op386SETGE(v) case Op386SETL: - return rewriteValue386_Op386SETL(v, config) + return rewriteValue386_Op386SETL(v) case Op386SETLE: - return rewriteValue386_Op386SETLE(v, config) + return rewriteValue386_Op386SETLE(v) case Op386SETNE: - return rewriteValue386_Op386SETNE(v, config) + return rewriteValue386_Op386SETNE(v) case Op386SHLL: - return rewriteValue386_Op386SHLL(v, config) + return rewriteValue386_Op386SHLL(v) case Op386SHLLconst: - return rewriteValue386_Op386SHLLconst(v, config) + return rewriteValue386_Op386SHLLconst(v) case Op386SHRB: - return rewriteValue386_Op386SHRB(v, config) + return rewriteValue386_Op386SHRB(v) case Op386SHRBconst: - return rewriteValue386_Op386SHRBconst(v, config) + return rewriteValue386_Op386SHRBconst(v) case Op386SHRL: - return rewriteValue386_Op386SHRL(v, config) + return rewriteValue386_Op386SHRL(v) case Op386SHRLconst: - return rewriteValue386_Op386SHRLconst(v, config) + return rewriteValue386_Op386SHRLconst(v) case Op386SHRW: - return rewriteValue386_Op386SHRW(v, config) + return rewriteValue386_Op386SHRW(v) case Op386SHRWconst: - return rewriteValue386_Op386SHRWconst(v, config) + return rewriteValue386_Op386SHRWconst(v) case Op386SUBL: - return rewriteValue386_Op386SUBL(v, config) + return rewriteValue386_Op386SUBL(v) case Op386SUBLcarry: - return rewriteValue386_Op386SUBLcarry(v, config) + return rewriteValue386_Op386SUBLcarry(v) case Op386SUBLconst: - return rewriteValue386_Op386SUBLconst(v, config) + return rewriteValue386_Op386SUBLconst(v) case Op386XORL: - return rewriteValue386_Op386XORL(v, config) + return rewriteValue386_Op386XORL(v) case Op386XORLconst: - return rewriteValue386_Op386XORLconst(v, config) + return rewriteValue386_Op386XORLconst(v) case OpAdd16: - return rewriteValue386_OpAdd16(v, config) + return rewriteValue386_OpAdd16(v) case OpAdd32: - return rewriteValue386_OpAdd32(v, config) + return rewriteValue386_OpAdd32(v) case OpAdd32F: - return rewriteValue386_OpAdd32F(v, config) + return rewriteValue386_OpAdd32F(v) case OpAdd32carry: - return rewriteValue386_OpAdd32carry(v, config) + return rewriteValue386_OpAdd32carry(v) case OpAdd32withcarry: - return rewriteValue386_OpAdd32withcarry(v, config) + return rewriteValue386_OpAdd32withcarry(v) case OpAdd64F: - return rewriteValue386_OpAdd64F(v, config) + return rewriteValue386_OpAdd64F(v) case OpAdd8: - return rewriteValue386_OpAdd8(v, config) + return rewriteValue386_OpAdd8(v) case OpAddPtr: - return rewriteValue386_OpAddPtr(v, config) + return rewriteValue386_OpAddPtr(v) case OpAddr: - return rewriteValue386_OpAddr(v, config) + return rewriteValue386_OpAddr(v) case OpAnd16: - return rewriteValue386_OpAnd16(v, config) + return rewriteValue386_OpAnd16(v) case OpAnd32: - return rewriteValue386_OpAnd32(v, config) + return rewriteValue386_OpAnd32(v) case OpAnd8: - return rewriteValue386_OpAnd8(v, config) + return rewriteValue386_OpAnd8(v) case OpAndB: - return rewriteValue386_OpAndB(v, config) + return rewriteValue386_OpAndB(v) case OpAvg32u: - return rewriteValue386_OpAvg32u(v, config) + return rewriteValue386_OpAvg32u(v) case OpBswap32: - return rewriteValue386_OpBswap32(v, config) + return rewriteValue386_OpBswap32(v) case OpClosureCall: - return rewriteValue386_OpClosureCall(v, config) + return rewriteValue386_OpClosureCall(v) case OpCom16: - return rewriteValue386_OpCom16(v, config) + return rewriteValue386_OpCom16(v) case OpCom32: - return rewriteValue386_OpCom32(v, config) + return rewriteValue386_OpCom32(v) case OpCom8: - return rewriteValue386_OpCom8(v, config) + return rewriteValue386_OpCom8(v) case OpConst16: - return rewriteValue386_OpConst16(v, config) + return rewriteValue386_OpConst16(v) case OpConst32: - return rewriteValue386_OpConst32(v, config) + return rewriteValue386_OpConst32(v) case OpConst32F: - return rewriteValue386_OpConst32F(v, config) + return rewriteValue386_OpConst32F(v) case OpConst64F: - return rewriteValue386_OpConst64F(v, config) + return rewriteValue386_OpConst64F(v) case OpConst8: - return rewriteValue386_OpConst8(v, config) + return rewriteValue386_OpConst8(v) case OpConstBool: - return rewriteValue386_OpConstBool(v, config) + return rewriteValue386_OpConstBool(v) case OpConstNil: - return rewriteValue386_OpConstNil(v, config) + return rewriteValue386_OpConstNil(v) case OpConvert: - return rewriteValue386_OpConvert(v, config) + return rewriteValue386_OpConvert(v) case OpCvt32Fto32: - return rewriteValue386_OpCvt32Fto32(v, config) + return rewriteValue386_OpCvt32Fto32(v) case OpCvt32Fto64F: - return rewriteValue386_OpCvt32Fto64F(v, config) + return rewriteValue386_OpCvt32Fto64F(v) case OpCvt32to32F: - return rewriteValue386_OpCvt32to32F(v, config) + return rewriteValue386_OpCvt32to32F(v) case OpCvt32to64F: - return rewriteValue386_OpCvt32to64F(v, config) + return rewriteValue386_OpCvt32to64F(v) case OpCvt64Fto32: - return rewriteValue386_OpCvt64Fto32(v, config) + return rewriteValue386_OpCvt64Fto32(v) case OpCvt64Fto32F: - return rewriteValue386_OpCvt64Fto32F(v, config) + return rewriteValue386_OpCvt64Fto32F(v) case OpDiv16: - return rewriteValue386_OpDiv16(v, config) + return rewriteValue386_OpDiv16(v) case OpDiv16u: - return rewriteValue386_OpDiv16u(v, config) + return rewriteValue386_OpDiv16u(v) case OpDiv32: - return rewriteValue386_OpDiv32(v, config) + return rewriteValue386_OpDiv32(v) case OpDiv32F: - return rewriteValue386_OpDiv32F(v, config) + return rewriteValue386_OpDiv32F(v) case OpDiv32u: - return rewriteValue386_OpDiv32u(v, config) + return rewriteValue386_OpDiv32u(v) case OpDiv64F: - return rewriteValue386_OpDiv64F(v, config) + return rewriteValue386_OpDiv64F(v) case OpDiv8: - return rewriteValue386_OpDiv8(v, config) + return rewriteValue386_OpDiv8(v) case OpDiv8u: - return rewriteValue386_OpDiv8u(v, config) + return rewriteValue386_OpDiv8u(v) case OpEq16: - return rewriteValue386_OpEq16(v, config) + return rewriteValue386_OpEq16(v) case OpEq32: - return rewriteValue386_OpEq32(v, config) + return rewriteValue386_OpEq32(v) case OpEq32F: - return rewriteValue386_OpEq32F(v, config) + return rewriteValue386_OpEq32F(v) case OpEq64F: - return rewriteValue386_OpEq64F(v, config) + return rewriteValue386_OpEq64F(v) case OpEq8: - return rewriteValue386_OpEq8(v, config) + return rewriteValue386_OpEq8(v) case OpEqB: - return rewriteValue386_OpEqB(v, config) + return rewriteValue386_OpEqB(v) case OpEqPtr: - return rewriteValue386_OpEqPtr(v, config) + return rewriteValue386_OpEqPtr(v) case OpGeq16: - return rewriteValue386_OpGeq16(v, config) + return rewriteValue386_OpGeq16(v) case OpGeq16U: - return rewriteValue386_OpGeq16U(v, config) + return rewriteValue386_OpGeq16U(v) case OpGeq32: - return rewriteValue386_OpGeq32(v, config) + return rewriteValue386_OpGeq32(v) case OpGeq32F: - return rewriteValue386_OpGeq32F(v, config) + return rewriteValue386_OpGeq32F(v) case OpGeq32U: - return rewriteValue386_OpGeq32U(v, config) + return rewriteValue386_OpGeq32U(v) case OpGeq64F: - return rewriteValue386_OpGeq64F(v, config) + return rewriteValue386_OpGeq64F(v) case OpGeq8: - return rewriteValue386_OpGeq8(v, config) + return rewriteValue386_OpGeq8(v) case OpGeq8U: - return rewriteValue386_OpGeq8U(v, config) + return rewriteValue386_OpGeq8U(v) case OpGetClosurePtr: - return rewriteValue386_OpGetClosurePtr(v, config) + return rewriteValue386_OpGetClosurePtr(v) case OpGetG: - return rewriteValue386_OpGetG(v, config) + return rewriteValue386_OpGetG(v) case OpGreater16: - return rewriteValue386_OpGreater16(v, config) + return rewriteValue386_OpGreater16(v) case OpGreater16U: - return rewriteValue386_OpGreater16U(v, config) + return rewriteValue386_OpGreater16U(v) case OpGreater32: - return rewriteValue386_OpGreater32(v, config) + return rewriteValue386_OpGreater32(v) case OpGreater32F: - return rewriteValue386_OpGreater32F(v, config) + return rewriteValue386_OpGreater32F(v) case OpGreater32U: - return rewriteValue386_OpGreater32U(v, config) + return rewriteValue386_OpGreater32U(v) case OpGreater64F: - return rewriteValue386_OpGreater64F(v, config) + return rewriteValue386_OpGreater64F(v) case OpGreater8: - return rewriteValue386_OpGreater8(v, config) + return rewriteValue386_OpGreater8(v) case OpGreater8U: - return rewriteValue386_OpGreater8U(v, config) + return rewriteValue386_OpGreater8U(v) case OpHmul32: - return rewriteValue386_OpHmul32(v, config) + return rewriteValue386_OpHmul32(v) case OpHmul32u: - return rewriteValue386_OpHmul32u(v, config) + return rewriteValue386_OpHmul32u(v) case OpInterCall: - return rewriteValue386_OpInterCall(v, config) + return rewriteValue386_OpInterCall(v) case OpIsInBounds: - return rewriteValue386_OpIsInBounds(v, config) + return rewriteValue386_OpIsInBounds(v) case OpIsNonNil: - return rewriteValue386_OpIsNonNil(v, config) + return rewriteValue386_OpIsNonNil(v) case OpIsSliceInBounds: - return rewriteValue386_OpIsSliceInBounds(v, config) + return rewriteValue386_OpIsSliceInBounds(v) case OpLeq16: - return rewriteValue386_OpLeq16(v, config) + return rewriteValue386_OpLeq16(v) case OpLeq16U: - return rewriteValue386_OpLeq16U(v, config) + return rewriteValue386_OpLeq16U(v) case OpLeq32: - return rewriteValue386_OpLeq32(v, config) + return rewriteValue386_OpLeq32(v) case OpLeq32F: - return rewriteValue386_OpLeq32F(v, config) + return rewriteValue386_OpLeq32F(v) case OpLeq32U: - return rewriteValue386_OpLeq32U(v, config) + return rewriteValue386_OpLeq32U(v) case OpLeq64F: - return rewriteValue386_OpLeq64F(v, config) + return rewriteValue386_OpLeq64F(v) case OpLeq8: - return rewriteValue386_OpLeq8(v, config) + return rewriteValue386_OpLeq8(v) case OpLeq8U: - return rewriteValue386_OpLeq8U(v, config) + return rewriteValue386_OpLeq8U(v) case OpLess16: - return rewriteValue386_OpLess16(v, config) + return rewriteValue386_OpLess16(v) case OpLess16U: - return rewriteValue386_OpLess16U(v, config) + return rewriteValue386_OpLess16U(v) case OpLess32: - return rewriteValue386_OpLess32(v, config) + return rewriteValue386_OpLess32(v) case OpLess32F: - return rewriteValue386_OpLess32F(v, config) + return rewriteValue386_OpLess32F(v) case OpLess32U: - return rewriteValue386_OpLess32U(v, config) + return rewriteValue386_OpLess32U(v) case OpLess64F: - return rewriteValue386_OpLess64F(v, config) + return rewriteValue386_OpLess64F(v) case OpLess8: - return rewriteValue386_OpLess8(v, config) + return rewriteValue386_OpLess8(v) case OpLess8U: - return rewriteValue386_OpLess8U(v, config) + return rewriteValue386_OpLess8U(v) case OpLoad: - return rewriteValue386_OpLoad(v, config) + return rewriteValue386_OpLoad(v) case OpLsh16x16: - return rewriteValue386_OpLsh16x16(v, config) + return rewriteValue386_OpLsh16x16(v) case OpLsh16x32: - return rewriteValue386_OpLsh16x32(v, config) + return rewriteValue386_OpLsh16x32(v) case OpLsh16x64: - return rewriteValue386_OpLsh16x64(v, config) + return rewriteValue386_OpLsh16x64(v) case OpLsh16x8: - return rewriteValue386_OpLsh16x8(v, config) + return rewriteValue386_OpLsh16x8(v) case OpLsh32x16: - return rewriteValue386_OpLsh32x16(v, config) + return rewriteValue386_OpLsh32x16(v) case OpLsh32x32: - return rewriteValue386_OpLsh32x32(v, config) + return rewriteValue386_OpLsh32x32(v) case OpLsh32x64: - return rewriteValue386_OpLsh32x64(v, config) + return rewriteValue386_OpLsh32x64(v) case OpLsh32x8: - return rewriteValue386_OpLsh32x8(v, config) + return rewriteValue386_OpLsh32x8(v) case OpLsh8x16: - return rewriteValue386_OpLsh8x16(v, config) + return rewriteValue386_OpLsh8x16(v) case OpLsh8x32: - return rewriteValue386_OpLsh8x32(v, config) + return rewriteValue386_OpLsh8x32(v) case OpLsh8x64: - return rewriteValue386_OpLsh8x64(v, config) + return rewriteValue386_OpLsh8x64(v) case OpLsh8x8: - return rewriteValue386_OpLsh8x8(v, config) + return rewriteValue386_OpLsh8x8(v) case OpMod16: - return rewriteValue386_OpMod16(v, config) + return rewriteValue386_OpMod16(v) case OpMod16u: - return rewriteValue386_OpMod16u(v, config) + return rewriteValue386_OpMod16u(v) case OpMod32: - return rewriteValue386_OpMod32(v, config) + return rewriteValue386_OpMod32(v) case OpMod32u: - return rewriteValue386_OpMod32u(v, config) + return rewriteValue386_OpMod32u(v) case OpMod8: - return rewriteValue386_OpMod8(v, config) + return rewriteValue386_OpMod8(v) case OpMod8u: - return rewriteValue386_OpMod8u(v, config) + return rewriteValue386_OpMod8u(v) case OpMove: - return rewriteValue386_OpMove(v, config) + return rewriteValue386_OpMove(v) case OpMul16: - return rewriteValue386_OpMul16(v, config) + return rewriteValue386_OpMul16(v) case OpMul32: - return rewriteValue386_OpMul32(v, config) + return rewriteValue386_OpMul32(v) case OpMul32F: - return rewriteValue386_OpMul32F(v, config) + return rewriteValue386_OpMul32F(v) case OpMul32uhilo: - return rewriteValue386_OpMul32uhilo(v, config) + return rewriteValue386_OpMul32uhilo(v) case OpMul64F: - return rewriteValue386_OpMul64F(v, config) + return rewriteValue386_OpMul64F(v) case OpMul8: - return rewriteValue386_OpMul8(v, config) + return rewriteValue386_OpMul8(v) case OpNeg16: - return rewriteValue386_OpNeg16(v, config) + return rewriteValue386_OpNeg16(v) case OpNeg32: - return rewriteValue386_OpNeg32(v, config) + return rewriteValue386_OpNeg32(v) case OpNeg32F: - return rewriteValue386_OpNeg32F(v, config) + return rewriteValue386_OpNeg32F(v) case OpNeg64F: - return rewriteValue386_OpNeg64F(v, config) + return rewriteValue386_OpNeg64F(v) case OpNeg8: - return rewriteValue386_OpNeg8(v, config) + return rewriteValue386_OpNeg8(v) case OpNeq16: - return rewriteValue386_OpNeq16(v, config) + return rewriteValue386_OpNeq16(v) case OpNeq32: - return rewriteValue386_OpNeq32(v, config) + return rewriteValue386_OpNeq32(v) case OpNeq32F: - return rewriteValue386_OpNeq32F(v, config) + return rewriteValue386_OpNeq32F(v) case OpNeq64F: - return rewriteValue386_OpNeq64F(v, config) + return rewriteValue386_OpNeq64F(v) case OpNeq8: - return rewriteValue386_OpNeq8(v, config) + return rewriteValue386_OpNeq8(v) case OpNeqB: - return rewriteValue386_OpNeqB(v, config) + return rewriteValue386_OpNeqB(v) case OpNeqPtr: - return rewriteValue386_OpNeqPtr(v, config) + return rewriteValue386_OpNeqPtr(v) case OpNilCheck: - return rewriteValue386_OpNilCheck(v, config) + return rewriteValue386_OpNilCheck(v) case OpNot: - return rewriteValue386_OpNot(v, config) + return rewriteValue386_OpNot(v) case OpOffPtr: - return rewriteValue386_OpOffPtr(v, config) + return rewriteValue386_OpOffPtr(v) case OpOr16: - return rewriteValue386_OpOr16(v, config) + return rewriteValue386_OpOr16(v) case OpOr32: - return rewriteValue386_OpOr32(v, config) + return rewriteValue386_OpOr32(v) case OpOr8: - return rewriteValue386_OpOr8(v, config) + return rewriteValue386_OpOr8(v) case OpOrB: - return rewriteValue386_OpOrB(v, config) + return rewriteValue386_OpOrB(v) case OpRound32F: - return rewriteValue386_OpRound32F(v, config) + return rewriteValue386_OpRound32F(v) case OpRound64F: - return rewriteValue386_OpRound64F(v, config) + return rewriteValue386_OpRound64F(v) case OpRsh16Ux16: - return rewriteValue386_OpRsh16Ux16(v, config) + return rewriteValue386_OpRsh16Ux16(v) case OpRsh16Ux32: - return rewriteValue386_OpRsh16Ux32(v, config) + return rewriteValue386_OpRsh16Ux32(v) case OpRsh16Ux64: - return rewriteValue386_OpRsh16Ux64(v, config) + return rewriteValue386_OpRsh16Ux64(v) case OpRsh16Ux8: - return rewriteValue386_OpRsh16Ux8(v, config) + return rewriteValue386_OpRsh16Ux8(v) case OpRsh16x16: - return rewriteValue386_OpRsh16x16(v, config) + return rewriteValue386_OpRsh16x16(v) case OpRsh16x32: - return rewriteValue386_OpRsh16x32(v, config) + return rewriteValue386_OpRsh16x32(v) case OpRsh16x64: - return rewriteValue386_OpRsh16x64(v, config) + return rewriteValue386_OpRsh16x64(v) case OpRsh16x8: - return rewriteValue386_OpRsh16x8(v, config) + return rewriteValue386_OpRsh16x8(v) case OpRsh32Ux16: - return rewriteValue386_OpRsh32Ux16(v, config) + return rewriteValue386_OpRsh32Ux16(v) case OpRsh32Ux32: - return rewriteValue386_OpRsh32Ux32(v, config) + return rewriteValue386_OpRsh32Ux32(v) case OpRsh32Ux64: - return rewriteValue386_OpRsh32Ux64(v, config) + return rewriteValue386_OpRsh32Ux64(v) case OpRsh32Ux8: - return rewriteValue386_OpRsh32Ux8(v, config) + return rewriteValue386_OpRsh32Ux8(v) case OpRsh32x16: - return rewriteValue386_OpRsh32x16(v, config) + return rewriteValue386_OpRsh32x16(v) case OpRsh32x32: - return rewriteValue386_OpRsh32x32(v, config) + return rewriteValue386_OpRsh32x32(v) case OpRsh32x64: - return rewriteValue386_OpRsh32x64(v, config) + return rewriteValue386_OpRsh32x64(v) case OpRsh32x8: - return rewriteValue386_OpRsh32x8(v, config) + return rewriteValue386_OpRsh32x8(v) case OpRsh8Ux16: - return rewriteValue386_OpRsh8Ux16(v, config) + return rewriteValue386_OpRsh8Ux16(v) case OpRsh8Ux32: - return rewriteValue386_OpRsh8Ux32(v, config) + return rewriteValue386_OpRsh8Ux32(v) case OpRsh8Ux64: - return rewriteValue386_OpRsh8Ux64(v, config) + return rewriteValue386_OpRsh8Ux64(v) case OpRsh8Ux8: - return rewriteValue386_OpRsh8Ux8(v, config) + return rewriteValue386_OpRsh8Ux8(v) case OpRsh8x16: - return rewriteValue386_OpRsh8x16(v, config) + return rewriteValue386_OpRsh8x16(v) case OpRsh8x32: - return rewriteValue386_OpRsh8x32(v, config) + return rewriteValue386_OpRsh8x32(v) case OpRsh8x64: - return rewriteValue386_OpRsh8x64(v, config) + return rewriteValue386_OpRsh8x64(v) case OpRsh8x8: - return rewriteValue386_OpRsh8x8(v, config) + return rewriteValue386_OpRsh8x8(v) case OpSignExt16to32: - return rewriteValue386_OpSignExt16to32(v, config) + return rewriteValue386_OpSignExt16to32(v) case OpSignExt8to16: - return rewriteValue386_OpSignExt8to16(v, config) + return rewriteValue386_OpSignExt8to16(v) case OpSignExt8to32: - return rewriteValue386_OpSignExt8to32(v, config) + return rewriteValue386_OpSignExt8to32(v) case OpSignmask: - return rewriteValue386_OpSignmask(v, config) + return rewriteValue386_OpSignmask(v) case OpSlicemask: - return rewriteValue386_OpSlicemask(v, config) + return rewriteValue386_OpSlicemask(v) case OpSqrt: - return rewriteValue386_OpSqrt(v, config) + return rewriteValue386_OpSqrt(v) case OpStaticCall: - return rewriteValue386_OpStaticCall(v, config) + return rewriteValue386_OpStaticCall(v) case OpStore: - return rewriteValue386_OpStore(v, config) + return rewriteValue386_OpStore(v) case OpSub16: - return rewriteValue386_OpSub16(v, config) + return rewriteValue386_OpSub16(v) case OpSub32: - return rewriteValue386_OpSub32(v, config) + return rewriteValue386_OpSub32(v) case OpSub32F: - return rewriteValue386_OpSub32F(v, config) + return rewriteValue386_OpSub32F(v) case OpSub32carry: - return rewriteValue386_OpSub32carry(v, config) + return rewriteValue386_OpSub32carry(v) case OpSub32withcarry: - return rewriteValue386_OpSub32withcarry(v, config) + return rewriteValue386_OpSub32withcarry(v) case OpSub64F: - return rewriteValue386_OpSub64F(v, config) + return rewriteValue386_OpSub64F(v) case OpSub8: - return rewriteValue386_OpSub8(v, config) + return rewriteValue386_OpSub8(v) case OpSubPtr: - return rewriteValue386_OpSubPtr(v, config) + return rewriteValue386_OpSubPtr(v) case OpTrunc16to8: - return rewriteValue386_OpTrunc16to8(v, config) + return rewriteValue386_OpTrunc16to8(v) case OpTrunc32to16: - return rewriteValue386_OpTrunc32to16(v, config) + return rewriteValue386_OpTrunc32to16(v) case OpTrunc32to8: - return rewriteValue386_OpTrunc32to8(v, config) + return rewriteValue386_OpTrunc32to8(v) case OpXor16: - return rewriteValue386_OpXor16(v, config) + return rewriteValue386_OpXor16(v) case OpXor32: - return rewriteValue386_OpXor32(v, config) + return rewriteValue386_OpXor32(v) case OpXor8: - return rewriteValue386_OpXor8(v, config) + return rewriteValue386_OpXor8(v) case OpZero: - return rewriteValue386_OpZero(v, config) + return rewriteValue386_OpZero(v) case OpZeroExt16to32: - return rewriteValue386_OpZeroExt16to32(v, config) + return rewriteValue386_OpZeroExt16to32(v) case OpZeroExt8to16: - return rewriteValue386_OpZeroExt8to16(v, config) + return rewriteValue386_OpZeroExt8to16(v) case OpZeroExt8to32: - return rewriteValue386_OpZeroExt8to32(v, config) + return rewriteValue386_OpZeroExt8to32(v) case OpZeromask: - return rewriteValue386_OpZeromask(v, config) + return rewriteValue386_OpZeromask(v) } return false } -func rewriteValue386_Op386ADCL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ADCL(v *Value) bool { // match: (ADCL x (MOVLconst [c]) f) // cond: // result: (ADCLconst [c] x f) @@ -624,9 +622,7 @@ func rewriteValue386_Op386ADCL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ADDL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ADDL(v *Value) bool { // match: (ADDL x (MOVLconst [c])) // cond: // result: (ADDLconst [c] x) @@ -1026,9 +1022,7 @@ func rewriteValue386_Op386ADDL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ADDLcarry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ADDLcarry(v *Value) bool { // match: (ADDLcarry x (MOVLconst [c])) // cond: // result: (ADDLconstcarry [c] x) @@ -1061,9 +1055,7 @@ func rewriteValue386_Op386ADDLcarry(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ADDLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ADDLconst(v *Value) bool { // match: (ADDLconst [c] (ADDL x y)) // cond: // result: (LEAL1 [c] x y) @@ -1240,9 +1232,7 @@ func rewriteValue386_Op386ADDLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ANDL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ANDL(v *Value) bool { // match: (ANDL x (MOVLconst [c])) // cond: // result: (ANDLconst [c] x) @@ -1288,9 +1278,7 @@ func rewriteValue386_Op386ANDL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ANDLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ANDLconst(v *Value) bool { // match: (ANDLconst [c] (ANDLconst [d] x)) // cond: // result: (ANDLconst [c & d] x) @@ -1349,7 +1337,7 @@ func rewriteValue386_Op386ANDLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386CMPB(v *Value, config *Config) bool { +func rewriteValue386_Op386CMPB(v *Value) bool { b := v.Block _ = b // match: (CMPB x (MOVLconst [c])) @@ -1386,9 +1374,7 @@ func rewriteValue386_Op386CMPB(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386CMPBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386CMPBconst(v *Value) bool { // match: (CMPBconst (MOVLconst [x]) [y]) // cond: int8(x)==int8(y) // result: (FlagEQ) @@ -1536,7 +1522,7 @@ func rewriteValue386_Op386CMPBconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386CMPL(v *Value, config *Config) bool { +func rewriteValue386_Op386CMPL(v *Value) bool { b := v.Block _ = b // match: (CMPL x (MOVLconst [c])) @@ -1573,9 +1559,7 @@ func rewriteValue386_Op386CMPL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386CMPLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386CMPLconst(v *Value) bool { // match: (CMPLconst (MOVLconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -1739,7 +1723,7 @@ func rewriteValue386_Op386CMPLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386CMPW(v *Value, config *Config) bool { +func rewriteValue386_Op386CMPW(v *Value) bool { b := v.Block _ = b // match: (CMPW x (MOVLconst [c])) @@ -1776,9 +1760,7 @@ func rewriteValue386_Op386CMPW(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386CMPWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386CMPWconst(v *Value) bool { // match: (CMPWconst (MOVLconst [x]) [y]) // cond: int16(x)==int16(y) // result: (FlagEQ) @@ -1926,9 +1908,7 @@ func rewriteValue386_Op386CMPWconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386LEAL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386LEAL(v *Value) bool { // match: (LEAL [c] {s} (ADDLconst [d] x)) // cond: is32Bit(c+d) // result: (LEAL [c+d] {s} x) @@ -2092,9 +2072,7 @@ func rewriteValue386_Op386LEAL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386LEAL1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386LEAL1(v *Value) bool { // match: (LEAL1 [c] {s} (ADDLconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAL1 [c+d] {s} x y) @@ -2323,9 +2301,7 @@ func rewriteValue386_Op386LEAL1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386LEAL2(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386LEAL2(v *Value) bool { // match: (LEAL2 [c] {s} (ADDLconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAL2 [c+d] {s} x y) @@ -2442,9 +2418,7 @@ func rewriteValue386_Op386LEAL2(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386LEAL4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386LEAL4(v *Value) bool { // match: (LEAL4 [c] {s} (ADDLconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAL4 [c+d] {s} x y) @@ -2539,9 +2513,7 @@ func rewriteValue386_Op386LEAL4(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386LEAL8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386LEAL8(v *Value) bool { // match: (LEAL8 [c] {s} (ADDLconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAL8 [c+d] {s} x y) @@ -2614,7 +2586,7 @@ func rewriteValue386_Op386LEAL8(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVBLSX(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVBLSX(v *Value) bool { b := v.Block _ = b // match: (MOVBLSX x:(MOVBload [off] {sym} ptr mem)) @@ -2662,9 +2634,11 @@ func rewriteValue386_Op386MOVBLSX(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVBLSXload(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVBLSXload(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVBLSXload [off1] {sym1} (LEAL [off2] {sym2} base) mem) // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) // result: (MOVBLSXload [off1+off2] {mergeSym(sym1,sym2)} base mem) @@ -2691,7 +2665,7 @@ func rewriteValue386_Op386MOVBLSXload(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVBLZX(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVBLZX(v *Value) bool { b := v.Block _ = b // match: (MOVBLZX x:(MOVBload [off] {sym} ptr mem)) @@ -2763,9 +2737,11 @@ func rewriteValue386_Op386MOVBLZX(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVBload(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVBload(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: x @@ -2888,9 +2864,7 @@ func rewriteValue386_Op386MOVBload(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVBloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVBloadidx1(v *Value) bool { // match: (MOVBloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVBloadidx1 [c+d] {sym} ptr idx mem) @@ -2937,9 +2911,11 @@ func rewriteValue386_Op386MOVBloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVBstore(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVBstore(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVBstore [off] {sym} ptr (MOVBLSX x) mem) // cond: // result: (MOVBstore [off] {sym} ptr x mem) @@ -3203,9 +3179,11 @@ func rewriteValue386_Op386MOVBstore(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVBstoreconst(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVBstoreconst(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVBstoreconst [sc] {s} (ADDLconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -3331,9 +3309,7 @@ func rewriteValue386_Op386MOVBstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVBstoreconstidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVBstoreconstidx1(v *Value) bool { // match: (MOVBstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem) // cond: // result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem) @@ -3414,9 +3390,7 @@ func rewriteValue386_Op386MOVBstoreconstidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVBstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVBstoreidx1(v *Value) bool { // match: (MOVBstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem) @@ -3568,9 +3542,11 @@ func rewriteValue386_Op386MOVBstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVLload(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVLload(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: x @@ -3719,9 +3695,7 @@ func rewriteValue386_Op386MOVLload(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVLloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVLloadidx1(v *Value) bool { // match: (MOVLloadidx1 [c] {sym} ptr (SHLLconst [2] idx) mem) // cond: // result: (MOVLloadidx4 [c] {sym} ptr idx mem) @@ -3792,9 +3766,7 @@ func rewriteValue386_Op386MOVLloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVLloadidx4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVLloadidx4(v *Value) bool { // match: (MOVLloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVLloadidx4 [c+d] {sym} ptr idx mem) @@ -3841,9 +3813,11 @@ func rewriteValue386_Op386MOVLloadidx4(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVLstore(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVLstore(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVLstore [off1] {sym} (ADDLconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVLstore [off1+off2] {sym} ptr val mem) @@ -4002,9 +3976,11 @@ func rewriteValue386_Op386MOVLstore(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVLstoreconst(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVLstoreconst(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVLstoreconst [sc] {s} (ADDLconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -4127,9 +4103,7 @@ func rewriteValue386_Op386MOVLstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVLstoreconstidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVLstoreconstidx1(v *Value) bool { // match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLLconst [2] idx) mem) // cond: // result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem) @@ -4200,9 +4174,7 @@ func rewriteValue386_Op386MOVLstoreconstidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVLstoreconstidx4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVLstoreconstidx4(v *Value) bool { // match: (MOVLstoreconstidx4 [x] {sym} (ADDLconst [c] ptr) idx mem) // cond: // result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem) @@ -4249,9 +4221,7 @@ func rewriteValue386_Op386MOVLstoreconstidx4(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVLstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVLstoreidx1(v *Value) bool { // match: (MOVLstoreidx1 [c] {sym} ptr (SHLLconst [2] idx) val mem) // cond: // result: (MOVLstoreidx4 [c] {sym} ptr idx val mem) @@ -4328,9 +4298,7 @@ func rewriteValue386_Op386MOVLstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVLstoreidx4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVLstoreidx4(v *Value) bool { // match: (MOVLstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVLstoreidx4 [c+d] {sym} ptr idx val mem) @@ -4381,9 +4349,13 @@ func rewriteValue386_Op386MOVLstoreidx4(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSDconst(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVSDconst(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (MOVSDconst [c]) // cond: config.ctxt.Flag_shared // result: (MOVSDconst2 (MOVSDconst1 [c])) @@ -4393,16 +4365,18 @@ func rewriteValue386_Op386MOVSDconst(v *Value, config *Config) bool { break } v.reset(Op386MOVSDconst2) - v0 := b.NewValue0(v.Pos, Op386MOVSDconst1, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386MOVSDconst1, fe.TypeUInt32()) v0.AuxInt = c v.AddArg(v0) return true } return false } -func rewriteValue386_Op386MOVSDload(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVSDload(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVSDload [off1] {sym} (ADDLconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVSDload [off1+off2] {sym} ptr mem) @@ -4528,9 +4502,7 @@ func rewriteValue386_Op386MOVSDload(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSDloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVSDloadidx1(v *Value) bool { // match: (MOVSDloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVSDloadidx1 [c+d] {sym} ptr idx mem) @@ -4577,9 +4549,7 @@ func rewriteValue386_Op386MOVSDloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSDloadidx8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVSDloadidx8(v *Value) bool { // match: (MOVSDloadidx8 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem) @@ -4626,9 +4596,11 @@ func rewriteValue386_Op386MOVSDloadidx8(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSDstore(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVSDstore(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVSDstore [off1] {sym} (ADDLconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVSDstore [off1+off2] {sym} ptr val mem) @@ -4764,9 +4736,7 @@ func rewriteValue386_Op386MOVSDstore(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSDstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVSDstoreidx1(v *Value) bool { // match: (MOVSDstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVSDstoreidx1 [c+d] {sym} ptr idx val mem) @@ -4817,9 +4787,7 @@ func rewriteValue386_Op386MOVSDstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSDstoreidx8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVSDstoreidx8(v *Value) bool { // match: (MOVSDstoreidx8 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem) @@ -4870,9 +4838,13 @@ func rewriteValue386_Op386MOVSDstoreidx8(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSSconst(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVSSconst(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (MOVSSconst [c]) // cond: config.ctxt.Flag_shared // result: (MOVSSconst2 (MOVSSconst1 [c])) @@ -4882,16 +4854,18 @@ func rewriteValue386_Op386MOVSSconst(v *Value, config *Config) bool { break } v.reset(Op386MOVSSconst2) - v0 := b.NewValue0(v.Pos, Op386MOVSSconst1, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386MOVSSconst1, fe.TypeUInt32()) v0.AuxInt = c v.AddArg(v0) return true } return false } -func rewriteValue386_Op386MOVSSload(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVSSload(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVSSload [off1] {sym} (ADDLconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVSSload [off1+off2] {sym} ptr mem) @@ -5017,9 +4991,7 @@ func rewriteValue386_Op386MOVSSload(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSSloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVSSloadidx1(v *Value) bool { // match: (MOVSSloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVSSloadidx1 [c+d] {sym} ptr idx mem) @@ -5066,9 +5038,7 @@ func rewriteValue386_Op386MOVSSloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSSloadidx4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVSSloadidx4(v *Value) bool { // match: (MOVSSloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem) @@ -5115,9 +5085,11 @@ func rewriteValue386_Op386MOVSSloadidx4(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSSstore(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVSSstore(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVSSstore [off1] {sym} (ADDLconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVSSstore [off1+off2] {sym} ptr val mem) @@ -5253,9 +5225,7 @@ func rewriteValue386_Op386MOVSSstore(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSSstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVSSstoreidx1(v *Value) bool { // match: (MOVSSstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVSSstoreidx1 [c+d] {sym} ptr idx val mem) @@ -5306,9 +5276,7 @@ func rewriteValue386_Op386MOVSSstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVSSstoreidx4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVSSstoreidx4(v *Value) bool { // match: (MOVSSstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem) @@ -5359,7 +5327,7 @@ func rewriteValue386_Op386MOVSSstoreidx4(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWLSX(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVWLSX(v *Value) bool { b := v.Block _ = b // match: (MOVWLSX x:(MOVWload [off] {sym} ptr mem)) @@ -5407,9 +5375,11 @@ func rewriteValue386_Op386MOVWLSX(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWLSXload(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVWLSXload(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVWLSXload [off1] {sym1} (LEAL [off2] {sym2} base) mem) // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) // result: (MOVWLSXload [off1+off2] {mergeSym(sym1,sym2)} base mem) @@ -5436,7 +5406,7 @@ func rewriteValue386_Op386MOVWLSXload(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWLZX(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVWLZX(v *Value) bool { b := v.Block _ = b // match: (MOVWLZX x:(MOVWload [off] {sym} ptr mem)) @@ -5535,9 +5505,11 @@ func rewriteValue386_Op386MOVWLZX(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWload(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVWload(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: x @@ -5686,9 +5658,7 @@ func rewriteValue386_Op386MOVWload(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVWloadidx1(v *Value) bool { // match: (MOVWloadidx1 [c] {sym} ptr (SHLLconst [1] idx) mem) // cond: // result: (MOVWloadidx2 [c] {sym} ptr idx mem) @@ -5759,9 +5729,7 @@ func rewriteValue386_Op386MOVWloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWloadidx2(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVWloadidx2(v *Value) bool { // match: (MOVWloadidx2 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVWloadidx2 [c+d] {sym} ptr idx mem) @@ -5808,9 +5776,11 @@ func rewriteValue386_Op386MOVWloadidx2(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWstore(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVWstore(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVWstore [off] {sym} ptr (MOVWLSX x) mem) // cond: // result: (MOVWstore [off] {sym} ptr x mem) @@ -6102,9 +6072,11 @@ func rewriteValue386_Op386MOVWstore(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWstoreconst(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVWstoreconst(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVWstoreconst [sc] {s} (ADDLconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -6256,9 +6228,7 @@ func rewriteValue386_Op386MOVWstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWstoreconstidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVWstoreconstidx1(v *Value) bool { // match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLLconst [1] idx) mem) // cond: // result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem) @@ -6363,7 +6333,7 @@ func rewriteValue386_Op386MOVWstoreconstidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWstoreconstidx2(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVWstoreconstidx2(v *Value) bool { b := v.Block _ = b // match: (MOVWstoreconstidx2 [x] {sym} (ADDLconst [c] ptr) idx mem) @@ -6449,9 +6419,7 @@ func rewriteValue386_Op386MOVWstoreconstidx2(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MOVWstoreidx1(v *Value) bool { // match: (MOVWstoreidx1 [c] {sym} ptr (SHLLconst [1] idx) val mem) // cond: // result: (MOVWstoreidx2 [c] {sym} ptr idx val mem) @@ -6629,7 +6597,7 @@ func rewriteValue386_Op386MOVWstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MOVWstoreidx2(v *Value, config *Config) bool { +func rewriteValue386_Op386MOVWstoreidx2(v *Value) bool { b := v.Block _ = b // match: (MOVWstoreidx2 [c] {sym} (ADDLconst [d] ptr) idx val mem) @@ -6789,9 +6757,7 @@ func rewriteValue386_Op386MOVWstoreidx2(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MULL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386MULL(v *Value) bool { // match: (MULL x (MOVLconst [c])) // cond: // result: (MULLconst [c] x) @@ -6824,7 +6790,7 @@ func rewriteValue386_Op386MULL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386MULLconst(v *Value, config *Config) bool { +func rewriteValue386_Op386MULLconst(v *Value) bool { b := v.Block _ = b // match: (MULLconst [c] (MULLconst [d] x)) @@ -7211,9 +7177,7 @@ func rewriteValue386_Op386MULLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386NEGL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386NEGL(v *Value) bool { // match: (NEGL (MOVLconst [c])) // cond: // result: (MOVLconst [int64(int32(-c))]) @@ -7229,9 +7193,7 @@ func rewriteValue386_Op386NEGL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386NOTL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386NOTL(v *Value) bool { // match: (NOTL (MOVLconst [c])) // cond: // result: (MOVLconst [^c]) @@ -7247,9 +7209,13 @@ func rewriteValue386_Op386NOTL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ORL(v *Value, config *Config) bool { +func rewriteValue386_Op386ORL(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ORL x (MOVLconst [c])) // cond: // result: (ORLconst [c] x) @@ -7515,7 +7481,7 @@ func rewriteValue386_Op386ORL(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1) - v0 := b.NewValue0(v.Pos, Op386MOVWload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i @@ -7590,7 +7556,7 @@ func rewriteValue386_Op386ORL(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1, x2) - v0 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i @@ -7737,9 +7703,7 @@ func rewriteValue386_Op386ORL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ORLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ORLconst(v *Value) bool { // match: (ORLconst [c] x) // cond: int32(c)==0 // result: x @@ -7782,9 +7746,7 @@ func rewriteValue386_Op386ORLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ROLBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ROLBconst(v *Value) bool { // match: (ROLBconst [c] (ROLBconst [d] x)) // cond: // result: (ROLBconst [(c+d)& 7] x) @@ -7816,9 +7778,7 @@ func rewriteValue386_Op386ROLBconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ROLLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ROLLconst(v *Value) bool { // match: (ROLLconst [c] (ROLLconst [d] x)) // cond: // result: (ROLLconst [(c+d)&31] x) @@ -7850,9 +7810,7 @@ func rewriteValue386_Op386ROLLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386ROLWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386ROLWconst(v *Value) bool { // match: (ROLWconst [c] (ROLWconst [d] x)) // cond: // result: (ROLWconst [(c+d)&15] x) @@ -7884,9 +7842,7 @@ func rewriteValue386_Op386ROLWconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SARB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SARB(v *Value) bool { // match: (SARB x (MOVLconst [c])) // cond: // result: (SARBconst [min(c&31,7)] x) @@ -7904,9 +7860,7 @@ func rewriteValue386_Op386SARB(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SARBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SARBconst(v *Value) bool { // match: (SARBconst x [0]) // cond: // result: x @@ -7936,9 +7890,7 @@ func rewriteValue386_Op386SARBconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SARL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SARL(v *Value) bool { // match: (SARL x (MOVLconst [c])) // cond: // result: (SARLconst [c&31] x) @@ -7974,9 +7926,7 @@ func rewriteValue386_Op386SARL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SARLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SARLconst(v *Value) bool { // match: (SARLconst x [0]) // cond: // result: x @@ -8006,9 +7956,7 @@ func rewriteValue386_Op386SARLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SARW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SARW(v *Value) bool { // match: (SARW x (MOVLconst [c])) // cond: // result: (SARWconst [min(c&31,15)] x) @@ -8026,9 +7974,7 @@ func rewriteValue386_Op386SARW(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SARWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SARWconst(v *Value) bool { // match: (SARWconst x [0]) // cond: // result: x @@ -8058,9 +8004,7 @@ func rewriteValue386_Op386SARWconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SBBL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SBBL(v *Value) bool { // match: (SBBL x (MOVLconst [c]) f) // cond: // result: (SBBLconst [c] x f) @@ -8080,9 +8024,7 @@ func rewriteValue386_Op386SBBL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SBBLcarrymask(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SBBLcarrymask(v *Value) bool { // match: (SBBLcarrymask (FlagEQ)) // cond: // result: (MOVLconst [0]) @@ -8145,9 +8087,7 @@ func rewriteValue386_Op386SBBLcarrymask(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETA(v *Value) bool { // match: (SETA (InvertFlags x)) // cond: // result: (SETB x) @@ -8223,9 +8163,7 @@ func rewriteValue386_Op386SETA(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETAE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETAE(v *Value) bool { // match: (SETAE (InvertFlags x)) // cond: // result: (SETBE x) @@ -8301,9 +8239,7 @@ func rewriteValue386_Op386SETAE(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETB(v *Value) bool { // match: (SETB (InvertFlags x)) // cond: // result: (SETA x) @@ -8379,9 +8315,7 @@ func rewriteValue386_Op386SETB(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETBE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETBE(v *Value) bool { // match: (SETBE (InvertFlags x)) // cond: // result: (SETAE x) @@ -8457,9 +8391,7 @@ func rewriteValue386_Op386SETBE(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETEQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETEQ(v *Value) bool { // match: (SETEQ (InvertFlags x)) // cond: // result: (SETEQ x) @@ -8535,9 +8467,7 @@ func rewriteValue386_Op386SETEQ(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETG(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETG(v *Value) bool { // match: (SETG (InvertFlags x)) // cond: // result: (SETL x) @@ -8613,9 +8543,7 @@ func rewriteValue386_Op386SETG(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETGE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETGE(v *Value) bool { // match: (SETGE (InvertFlags x)) // cond: // result: (SETLE x) @@ -8691,9 +8619,7 @@ func rewriteValue386_Op386SETGE(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETL(v *Value) bool { // match: (SETL (InvertFlags x)) // cond: // result: (SETG x) @@ -8769,9 +8695,7 @@ func rewriteValue386_Op386SETL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETLE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETLE(v *Value) bool { // match: (SETLE (InvertFlags x)) // cond: // result: (SETGE x) @@ -8847,9 +8771,7 @@ func rewriteValue386_Op386SETLE(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SETNE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SETNE(v *Value) bool { // match: (SETNE (InvertFlags x)) // cond: // result: (SETNE x) @@ -8925,9 +8847,7 @@ func rewriteValue386_Op386SETNE(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SHLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SHLL(v *Value) bool { // match: (SHLL x (MOVLconst [c])) // cond: // result: (SHLLconst [c&31] x) @@ -8963,9 +8883,7 @@ func rewriteValue386_Op386SHLL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SHLLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SHLLconst(v *Value) bool { // match: (SHLLconst x [0]) // cond: // result: x @@ -8981,9 +8899,7 @@ func rewriteValue386_Op386SHLLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SHRB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SHRB(v *Value) bool { // match: (SHRB x (MOVLconst [c])) // cond: c&31 < 8 // result: (SHRBconst [c&31] x) @@ -9020,9 +8936,7 @@ func rewriteValue386_Op386SHRB(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SHRBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SHRBconst(v *Value) bool { // match: (SHRBconst x [0]) // cond: // result: x @@ -9038,9 +8952,7 @@ func rewriteValue386_Op386SHRBconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SHRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SHRL(v *Value) bool { // match: (SHRL x (MOVLconst [c])) // cond: // result: (SHRLconst [c&31] x) @@ -9076,9 +8988,7 @@ func rewriteValue386_Op386SHRL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SHRLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SHRLconst(v *Value) bool { // match: (SHRLconst x [0]) // cond: // result: x @@ -9094,9 +9004,7 @@ func rewriteValue386_Op386SHRLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SHRW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SHRW(v *Value) bool { // match: (SHRW x (MOVLconst [c])) // cond: c&31 < 16 // result: (SHRWconst [c&31] x) @@ -9133,9 +9041,7 @@ func rewriteValue386_Op386SHRW(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SHRWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SHRWconst(v *Value) bool { // match: (SHRWconst x [0]) // cond: // result: x @@ -9151,7 +9057,7 @@ func rewriteValue386_Op386SHRWconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SUBL(v *Value, config *Config) bool { +func rewriteValue386_Op386SUBL(v *Value) bool { b := v.Block _ = b // match: (SUBL x (MOVLconst [c])) @@ -9200,9 +9106,7 @@ func rewriteValue386_Op386SUBL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SUBLcarry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SUBLcarry(v *Value) bool { // match: (SUBLcarry x (MOVLconst [c])) // cond: // result: (SUBLconstcarry [c] x) @@ -9220,9 +9124,7 @@ func rewriteValue386_Op386SUBLcarry(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386SUBLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386SUBLconst(v *Value) bool { // match: (SUBLconst [c] x) // cond: int32(c) == 0 // result: x @@ -9249,9 +9151,7 @@ func rewriteValue386_Op386SUBLconst(v *Value, config *Config) bool { return true } } -func rewriteValue386_Op386XORL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386XORL(v *Value) bool { // match: (XORL x (MOVLconst [c])) // cond: // result: (XORLconst [c] x) @@ -9462,9 +9362,7 @@ func rewriteValue386_Op386XORL(v *Value, config *Config) bool { } return false } -func rewriteValue386_Op386XORLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_Op386XORLconst(v *Value) bool { // match: (XORLconst [c] (XORLconst [d] x)) // cond: // result: (XORLconst [c ^ d] x) @@ -9511,9 +9409,7 @@ func rewriteValue386_Op386XORLconst(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpAdd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAdd16(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADDL x y) @@ -9526,9 +9422,7 @@ func rewriteValue386_OpAdd16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAdd32(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADDL x y) @@ -9541,9 +9435,7 @@ func rewriteValue386_OpAdd32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAdd32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAdd32F(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDSS x y) @@ -9556,9 +9448,7 @@ func rewriteValue386_OpAdd32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAdd32carry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAdd32carry(v *Value) bool { // match: (Add32carry x y) // cond: // result: (ADDLcarry x y) @@ -9571,9 +9461,7 @@ func rewriteValue386_OpAdd32carry(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAdd32withcarry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAdd32withcarry(v *Value) bool { // match: (Add32withcarry x y c) // cond: // result: (ADCL x y c) @@ -9588,9 +9476,7 @@ func rewriteValue386_OpAdd32withcarry(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAdd64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAdd64F(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDSD x y) @@ -9603,9 +9489,7 @@ func rewriteValue386_OpAdd64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAdd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAdd8(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADDL x y) @@ -9618,9 +9502,7 @@ func rewriteValue386_OpAdd8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAddPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAddPtr(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADDL x y) @@ -9633,9 +9515,7 @@ func rewriteValue386_OpAddPtr(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAddr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAddr(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (LEAL {sym} base) @@ -9648,9 +9528,7 @@ func rewriteValue386_OpAddr(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAnd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAnd16(v *Value) bool { // match: (And16 x y) // cond: // result: (ANDL x y) @@ -9663,9 +9541,7 @@ func rewriteValue386_OpAnd16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAnd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAnd32(v *Value) bool { // match: (And32 x y) // cond: // result: (ANDL x y) @@ -9678,9 +9554,7 @@ func rewriteValue386_OpAnd32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAnd8(v *Value) bool { // match: (And8 x y) // cond: // result: (ANDL x y) @@ -9693,9 +9567,7 @@ func rewriteValue386_OpAnd8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAndB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAndB(v *Value) bool { // match: (AndB x y) // cond: // result: (ANDL x y) @@ -9708,9 +9580,7 @@ func rewriteValue386_OpAndB(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpAvg32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpAvg32u(v *Value) bool { // match: (Avg32u x y) // cond: // result: (AVGLU x y) @@ -9723,9 +9593,7 @@ func rewriteValue386_OpAvg32u(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpBswap32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpBswap32(v *Value) bool { // match: (Bswap32 x) // cond: // result: (BSWAPL x) @@ -9736,9 +9604,7 @@ func rewriteValue386_OpBswap32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpClosureCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpClosureCall(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -9755,9 +9621,7 @@ func rewriteValue386_OpClosureCall(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpCom16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpCom16(v *Value) bool { // match: (Com16 x) // cond: // result: (NOTL x) @@ -9768,9 +9632,7 @@ func rewriteValue386_OpCom16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpCom32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpCom32(v *Value) bool { // match: (Com32 x) // cond: // result: (NOTL x) @@ -9781,9 +9643,7 @@ func rewriteValue386_OpCom32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpCom8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpCom8(v *Value) bool { // match: (Com8 x) // cond: // result: (NOTL x) @@ -9794,9 +9654,7 @@ func rewriteValue386_OpCom8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpConst16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpConst16(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVLconst [val]) @@ -9807,9 +9665,7 @@ func rewriteValue386_OpConst16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpConst32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpConst32(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVLconst [val]) @@ -9820,9 +9676,7 @@ func rewriteValue386_OpConst32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpConst32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpConst32F(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVSSconst [val]) @@ -9833,9 +9687,7 @@ func rewriteValue386_OpConst32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpConst64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpConst64F(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVSDconst [val]) @@ -9846,9 +9698,7 @@ func rewriteValue386_OpConst64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpConst8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpConst8(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVLconst [val]) @@ -9859,9 +9709,7 @@ func rewriteValue386_OpConst8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpConstBool(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpConstBool(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVLconst [b]) @@ -9872,9 +9720,7 @@ func rewriteValue386_OpConstBool(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpConstNil(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpConstNil(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVLconst [0]) @@ -9884,9 +9730,7 @@ func rewriteValue386_OpConstNil(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpConvert(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpConvert(v *Value) bool { // match: (Convert <t> x mem) // cond: // result: (MOVLconvert <t> x mem) @@ -9901,9 +9745,7 @@ func rewriteValue386_OpConvert(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpCvt32Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpCvt32Fto32(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (CVTTSS2SL x) @@ -9914,9 +9756,7 @@ func rewriteValue386_OpCvt32Fto32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpCvt32Fto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpCvt32Fto64F(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (CVTSS2SD x) @@ -9927,9 +9767,7 @@ func rewriteValue386_OpCvt32Fto64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpCvt32to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpCvt32to32F(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (CVTSL2SS x) @@ -9940,9 +9778,7 @@ func rewriteValue386_OpCvt32to32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpCvt32to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpCvt32to64F(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (CVTSL2SD x) @@ -9953,9 +9789,7 @@ func rewriteValue386_OpCvt32to64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpCvt64Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpCvt64Fto32(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (CVTTSD2SL x) @@ -9966,9 +9800,7 @@ func rewriteValue386_OpCvt64Fto32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpCvt64Fto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpCvt64Fto32F(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (CVTSD2SS x) @@ -9979,9 +9811,7 @@ func rewriteValue386_OpCvt64Fto32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpDiv16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpDiv16(v *Value) bool { // match: (Div16 x y) // cond: // result: (DIVW x y) @@ -9994,9 +9824,7 @@ func rewriteValue386_OpDiv16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpDiv16u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpDiv16u(v *Value) bool { // match: (Div16u x y) // cond: // result: (DIVWU x y) @@ -10009,9 +9837,7 @@ func rewriteValue386_OpDiv16u(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpDiv32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpDiv32(v *Value) bool { // match: (Div32 x y) // cond: // result: (DIVL x y) @@ -10024,9 +9850,7 @@ func rewriteValue386_OpDiv32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpDiv32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpDiv32F(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVSS x y) @@ -10039,9 +9863,7 @@ func rewriteValue386_OpDiv32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpDiv32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpDiv32u(v *Value) bool { // match: (Div32u x y) // cond: // result: (DIVLU x y) @@ -10054,9 +9876,7 @@ func rewriteValue386_OpDiv32u(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpDiv64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpDiv64F(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVSD x y) @@ -10069,9 +9889,13 @@ func rewriteValue386_OpDiv64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpDiv8(v *Value, config *Config) bool { +func rewriteValue386_OpDiv8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8 x y) // cond: // result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) @@ -10079,18 +9903,22 @@ func rewriteValue386_OpDiv8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(Op386DIVW) - v0 := b.NewValue0(v.Pos, OpSignExt8to16, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to16, config.fe.TypeInt16()) + v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValue386_OpDiv8u(v *Value, config *Config) bool { +func rewriteValue386_OpDiv8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8u x y) // cond: // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) @@ -10098,16 +9926,16 @@ func rewriteValue386_OpDiv8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(Op386DIVWU) - v0 := b.NewValue0(v.Pos, OpZeroExt8to16, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to16, config.fe.TypeUInt16()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValue386_OpEq16(v *Value, config *Config) bool { +func rewriteValue386_OpEq16(v *Value) bool { b := v.Block _ = b // match: (Eq16 x y) @@ -10124,7 +9952,7 @@ func rewriteValue386_OpEq16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpEq32(v *Value, config *Config) bool { +func rewriteValue386_OpEq32(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -10141,7 +9969,7 @@ func rewriteValue386_OpEq32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpEq32F(v *Value, config *Config) bool { +func rewriteValue386_OpEq32F(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -10158,7 +9986,7 @@ func rewriteValue386_OpEq32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpEq64F(v *Value, config *Config) bool { +func rewriteValue386_OpEq64F(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -10175,7 +10003,7 @@ func rewriteValue386_OpEq64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpEq8(v *Value, config *Config) bool { +func rewriteValue386_OpEq8(v *Value) bool { b := v.Block _ = b // match: (Eq8 x y) @@ -10192,7 +10020,7 @@ func rewriteValue386_OpEq8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpEqB(v *Value, config *Config) bool { +func rewriteValue386_OpEqB(v *Value) bool { b := v.Block _ = b // match: (EqB x y) @@ -10209,7 +10037,7 @@ func rewriteValue386_OpEqB(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpEqPtr(v *Value, config *Config) bool { +func rewriteValue386_OpEqPtr(v *Value) bool { b := v.Block _ = b // match: (EqPtr x y) @@ -10226,7 +10054,7 @@ func rewriteValue386_OpEqPtr(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGeq16(v *Value, config *Config) bool { +func rewriteValue386_OpGeq16(v *Value) bool { b := v.Block _ = b // match: (Geq16 x y) @@ -10243,7 +10071,7 @@ func rewriteValue386_OpGeq16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGeq16U(v *Value, config *Config) bool { +func rewriteValue386_OpGeq16U(v *Value) bool { b := v.Block _ = b // match: (Geq16U x y) @@ -10260,7 +10088,7 @@ func rewriteValue386_OpGeq16U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGeq32(v *Value, config *Config) bool { +func rewriteValue386_OpGeq32(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -10277,7 +10105,7 @@ func rewriteValue386_OpGeq32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGeq32F(v *Value, config *Config) bool { +func rewriteValue386_OpGeq32F(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -10294,7 +10122,7 @@ func rewriteValue386_OpGeq32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGeq32U(v *Value, config *Config) bool { +func rewriteValue386_OpGeq32U(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -10311,7 +10139,7 @@ func rewriteValue386_OpGeq32U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGeq64F(v *Value, config *Config) bool { +func rewriteValue386_OpGeq64F(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -10328,7 +10156,7 @@ func rewriteValue386_OpGeq64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGeq8(v *Value, config *Config) bool { +func rewriteValue386_OpGeq8(v *Value) bool { b := v.Block _ = b // match: (Geq8 x y) @@ -10345,7 +10173,7 @@ func rewriteValue386_OpGeq8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGeq8U(v *Value, config *Config) bool { +func rewriteValue386_OpGeq8U(v *Value) bool { b := v.Block _ = b // match: (Geq8U x y) @@ -10362,9 +10190,7 @@ func rewriteValue386_OpGeq8U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGetClosurePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -10373,9 +10199,7 @@ func rewriteValue386_OpGetClosurePtr(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGetG(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpGetG(v *Value) bool { // match: (GetG mem) // cond: // result: (LoweredGetG mem) @@ -10386,7 +10210,7 @@ func rewriteValue386_OpGetG(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGreater16(v *Value, config *Config) bool { +func rewriteValue386_OpGreater16(v *Value) bool { b := v.Block _ = b // match: (Greater16 x y) @@ -10403,7 +10227,7 @@ func rewriteValue386_OpGreater16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGreater16U(v *Value, config *Config) bool { +func rewriteValue386_OpGreater16U(v *Value) bool { b := v.Block _ = b // match: (Greater16U x y) @@ -10420,7 +10244,7 @@ func rewriteValue386_OpGreater16U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGreater32(v *Value, config *Config) bool { +func rewriteValue386_OpGreater32(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -10437,7 +10261,7 @@ func rewriteValue386_OpGreater32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGreater32F(v *Value, config *Config) bool { +func rewriteValue386_OpGreater32F(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -10454,7 +10278,7 @@ func rewriteValue386_OpGreater32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGreater32U(v *Value, config *Config) bool { +func rewriteValue386_OpGreater32U(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -10471,7 +10295,7 @@ func rewriteValue386_OpGreater32U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGreater64F(v *Value, config *Config) bool { +func rewriteValue386_OpGreater64F(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -10488,7 +10312,7 @@ func rewriteValue386_OpGreater64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGreater8(v *Value, config *Config) bool { +func rewriteValue386_OpGreater8(v *Value) bool { b := v.Block _ = b // match: (Greater8 x y) @@ -10505,7 +10329,7 @@ func rewriteValue386_OpGreater8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpGreater8U(v *Value, config *Config) bool { +func rewriteValue386_OpGreater8U(v *Value) bool { b := v.Block _ = b // match: (Greater8U x y) @@ -10522,9 +10346,7 @@ func rewriteValue386_OpGreater8U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpHmul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpHmul32(v *Value) bool { // match: (Hmul32 x y) // cond: // result: (HMULL x y) @@ -10537,9 +10359,7 @@ func rewriteValue386_OpHmul32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpHmul32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpHmul32u(v *Value) bool { // match: (Hmul32u x y) // cond: // result: (HMULLU x y) @@ -10552,9 +10372,7 @@ func rewriteValue386_OpHmul32u(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpInterCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpInterCall(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -10569,7 +10387,7 @@ func rewriteValue386_OpInterCall(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpIsInBounds(v *Value, config *Config) bool { +func rewriteValue386_OpIsInBounds(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -10586,7 +10404,7 @@ func rewriteValue386_OpIsInBounds(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpIsNonNil(v *Value, config *Config) bool { +func rewriteValue386_OpIsNonNil(v *Value) bool { b := v.Block _ = b // match: (IsNonNil p) @@ -10602,7 +10420,7 @@ func rewriteValue386_OpIsNonNil(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpIsSliceInBounds(v *Value, config *Config) bool { +func rewriteValue386_OpIsSliceInBounds(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -10619,7 +10437,7 @@ func rewriteValue386_OpIsSliceInBounds(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLeq16(v *Value, config *Config) bool { +func rewriteValue386_OpLeq16(v *Value) bool { b := v.Block _ = b // match: (Leq16 x y) @@ -10636,7 +10454,7 @@ func rewriteValue386_OpLeq16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLeq16U(v *Value, config *Config) bool { +func rewriteValue386_OpLeq16U(v *Value) bool { b := v.Block _ = b // match: (Leq16U x y) @@ -10653,7 +10471,7 @@ func rewriteValue386_OpLeq16U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLeq32(v *Value, config *Config) bool { +func rewriteValue386_OpLeq32(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -10670,7 +10488,7 @@ func rewriteValue386_OpLeq32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLeq32F(v *Value, config *Config) bool { +func rewriteValue386_OpLeq32F(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -10687,7 +10505,7 @@ func rewriteValue386_OpLeq32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLeq32U(v *Value, config *Config) bool { +func rewriteValue386_OpLeq32U(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -10704,7 +10522,7 @@ func rewriteValue386_OpLeq32U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLeq64F(v *Value, config *Config) bool { +func rewriteValue386_OpLeq64F(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -10721,7 +10539,7 @@ func rewriteValue386_OpLeq64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLeq8(v *Value, config *Config) bool { +func rewriteValue386_OpLeq8(v *Value) bool { b := v.Block _ = b // match: (Leq8 x y) @@ -10738,7 +10556,7 @@ func rewriteValue386_OpLeq8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLeq8U(v *Value, config *Config) bool { +func rewriteValue386_OpLeq8U(v *Value) bool { b := v.Block _ = b // match: (Leq8U x y) @@ -10755,7 +10573,7 @@ func rewriteValue386_OpLeq8U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLess16(v *Value, config *Config) bool { +func rewriteValue386_OpLess16(v *Value) bool { b := v.Block _ = b // match: (Less16 x y) @@ -10772,7 +10590,7 @@ func rewriteValue386_OpLess16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLess16U(v *Value, config *Config) bool { +func rewriteValue386_OpLess16U(v *Value) bool { b := v.Block _ = b // match: (Less16U x y) @@ -10789,7 +10607,7 @@ func rewriteValue386_OpLess16U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLess32(v *Value, config *Config) bool { +func rewriteValue386_OpLess32(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -10806,7 +10624,7 @@ func rewriteValue386_OpLess32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLess32F(v *Value, config *Config) bool { +func rewriteValue386_OpLess32F(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -10823,7 +10641,7 @@ func rewriteValue386_OpLess32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLess32U(v *Value, config *Config) bool { +func rewriteValue386_OpLess32U(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -10840,7 +10658,7 @@ func rewriteValue386_OpLess32U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLess64F(v *Value, config *Config) bool { +func rewriteValue386_OpLess64F(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -10857,7 +10675,7 @@ func rewriteValue386_OpLess64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLess8(v *Value, config *Config) bool { +func rewriteValue386_OpLess8(v *Value) bool { b := v.Block _ = b // match: (Less8 x y) @@ -10874,7 +10692,7 @@ func rewriteValue386_OpLess8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLess8U(v *Value, config *Config) bool { +func rewriteValue386_OpLess8U(v *Value) bool { b := v.Block _ = b // match: (Less8U x y) @@ -10891,9 +10709,7 @@ func rewriteValue386_OpLess8U(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLoad(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpLoad(v *Value) bool { // match: (Load <t> ptr mem) // cond: (is32BitInt(t) || isPtr(t)) // result: (MOVLload ptr mem) @@ -10971,7 +10787,7 @@ func rewriteValue386_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpLsh16x16(v *Value, config *Config) bool { +func rewriteValue386_OpLsh16x16(v *Value) bool { b := v.Block _ = b // match: (Lsh16x16 <t> x y) @@ -10995,7 +10811,7 @@ func rewriteValue386_OpLsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLsh16x32(v *Value, config *Config) bool { +func rewriteValue386_OpLsh16x32(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 <t> x y) @@ -11019,9 +10835,7 @@ func rewriteValue386_OpLsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLsh16x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpLsh16x64(v *Value) bool { // match: (Lsh16x64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SHLLconst x [c]) @@ -11058,7 +10872,7 @@ func rewriteValue386_OpLsh16x64(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpLsh16x8(v *Value, config *Config) bool { +func rewriteValue386_OpLsh16x8(v *Value) bool { b := v.Block _ = b // match: (Lsh16x8 <t> x y) @@ -11082,7 +10896,7 @@ func rewriteValue386_OpLsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLsh32x16(v *Value, config *Config) bool { +func rewriteValue386_OpLsh32x16(v *Value) bool { b := v.Block _ = b // match: (Lsh32x16 <t> x y) @@ -11106,7 +10920,7 @@ func rewriteValue386_OpLsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLsh32x32(v *Value, config *Config) bool { +func rewriteValue386_OpLsh32x32(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 <t> x y) @@ -11130,9 +10944,7 @@ func rewriteValue386_OpLsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLsh32x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpLsh32x64(v *Value) bool { // match: (Lsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SHLLconst x [c]) @@ -11169,7 +10981,7 @@ func rewriteValue386_OpLsh32x64(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpLsh32x8(v *Value, config *Config) bool { +func rewriteValue386_OpLsh32x8(v *Value) bool { b := v.Block _ = b // match: (Lsh32x8 <t> x y) @@ -11193,7 +11005,7 @@ func rewriteValue386_OpLsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLsh8x16(v *Value, config *Config) bool { +func rewriteValue386_OpLsh8x16(v *Value) bool { b := v.Block _ = b // match: (Lsh8x16 <t> x y) @@ -11217,7 +11029,7 @@ func rewriteValue386_OpLsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLsh8x32(v *Value, config *Config) bool { +func rewriteValue386_OpLsh8x32(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 <t> x y) @@ -11241,9 +11053,7 @@ func rewriteValue386_OpLsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpLsh8x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpLsh8x64(v *Value) bool { // match: (Lsh8x64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SHLLconst x [c]) @@ -11280,7 +11090,7 @@ func rewriteValue386_OpLsh8x64(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpLsh8x8(v *Value, config *Config) bool { +func rewriteValue386_OpLsh8x8(v *Value) bool { b := v.Block _ = b // match: (Lsh8x8 <t> x y) @@ -11304,9 +11114,7 @@ func rewriteValue386_OpLsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMod16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMod16(v *Value) bool { // match: (Mod16 x y) // cond: // result: (MODW x y) @@ -11319,9 +11127,7 @@ func rewriteValue386_OpMod16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMod16u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMod16u(v *Value) bool { // match: (Mod16u x y) // cond: // result: (MODWU x y) @@ -11334,9 +11140,7 @@ func rewriteValue386_OpMod16u(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMod32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMod32(v *Value) bool { // match: (Mod32 x y) // cond: // result: (MODL x y) @@ -11349,9 +11153,7 @@ func rewriteValue386_OpMod32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMod32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMod32u(v *Value) bool { // match: (Mod32u x y) // cond: // result: (MODLU x y) @@ -11364,9 +11166,13 @@ func rewriteValue386_OpMod32u(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMod8(v *Value, config *Config) bool { +func rewriteValue386_OpMod8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8 x y) // cond: // result: (MODW (SignExt8to16 x) (SignExt8to16 y)) @@ -11374,18 +11180,22 @@ func rewriteValue386_OpMod8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(Op386MODW) - v0 := b.NewValue0(v.Pos, OpSignExt8to16, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to16, config.fe.TypeInt16()) + v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValue386_OpMod8u(v *Value, config *Config) bool { +func rewriteValue386_OpMod8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8u x y) // cond: // result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y)) @@ -11393,18 +11203,22 @@ func rewriteValue386_OpMod8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(Op386MODWU) - v0 := b.NewValue0(v.Pos, OpZeroExt8to16, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to16, config.fe.TypeUInt16()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValue386_OpMove(v *Value, config *Config) bool { +func rewriteValue386_OpMove(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Move [0] _ _ mem) // cond: // result: mem @@ -11430,7 +11244,7 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(Op386MOVBstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, Op386MOVBload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, Op386MOVBload, fe.TypeUInt8()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -11449,7 +11263,7 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(Op386MOVWstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, Op386MOVWload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -11468,7 +11282,7 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(Op386MOVLstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -11488,14 +11302,14 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { v.reset(Op386MOVBstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, Op386MOVBload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, Op386MOVBload, fe.TypeUInt8()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, Op386MOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, Op386MOVWload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -11516,14 +11330,14 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { v.reset(Op386MOVBstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, Op386MOVBload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, Op386MOVBload, fe.TypeUInt8()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -11544,14 +11358,14 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { v.reset(Op386MOVWstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, Op386MOVWload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -11572,14 +11386,14 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { v.reset(Op386MOVLstore) v.AuxInt = 3 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v0.AuxInt = 3 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -11600,14 +11414,14 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { v.reset(Op386MOVLstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -11638,7 +11452,7 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { v.AddArg(v1) v2 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v2.AddArg(dst) - v3 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v3.AddArg(src) v3.AddArg(mem) v2.AddArg(v3) @@ -11678,7 +11492,7 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { v.reset(Op386REPMOVSL) v.AddArg(dst) v.AddArg(src) - v0 := b.NewValue0(v.Pos, Op386MOVLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32()) v0.AuxInt = s / 4 v.AddArg(v0) v.AddArg(mem) @@ -11686,9 +11500,7 @@ func rewriteValue386_OpMove(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpMul16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMul16(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULL x y) @@ -11701,9 +11513,7 @@ func rewriteValue386_OpMul16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMul32(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULL x y) @@ -11716,9 +11526,7 @@ func rewriteValue386_OpMul32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMul32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMul32F(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULSS x y) @@ -11731,9 +11539,7 @@ func rewriteValue386_OpMul32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMul32uhilo(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMul32uhilo(v *Value) bool { // match: (Mul32uhilo x y) // cond: // result: (MULLQU x y) @@ -11746,9 +11552,7 @@ func rewriteValue386_OpMul32uhilo(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMul64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMul64F(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULSD x y) @@ -11761,9 +11565,7 @@ func rewriteValue386_OpMul64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpMul8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpMul8(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULL x y) @@ -11776,9 +11578,7 @@ func rewriteValue386_OpMul8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeg16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpNeg16(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEGL x) @@ -11789,9 +11589,7 @@ func rewriteValue386_OpNeg16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeg32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpNeg32(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEGL x) @@ -11802,12 +11600,16 @@ func rewriteValue386_OpNeg32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeg32F(v *Value, config *Config) bool { +func rewriteValue386_OpNeg32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neg32F x) // cond: !config.use387 - // result: (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> [f2i(math.Copysign(0, -1))])) + // result: (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))])) for { x := v.Args[0] if !(!config.use387) { @@ -11815,7 +11617,7 @@ func rewriteValue386_OpNeg32F(v *Value, config *Config) bool { } v.reset(Op386PXOR) v.AddArg(x) - v0 := b.NewValue0(v.Pos, Op386MOVSSconst, config.Frontend().TypeFloat32()) + v0 := b.NewValue0(v.Pos, Op386MOVSSconst, fe.TypeFloat32()) v0.AuxInt = f2i(math.Copysign(0, -1)) v.AddArg(v0) return true @@ -11834,12 +11636,16 @@ func rewriteValue386_OpNeg32F(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpNeg64F(v *Value, config *Config) bool { +func rewriteValue386_OpNeg64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neg64F x) // cond: !config.use387 - // result: (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> [f2i(math.Copysign(0, -1))])) + // result: (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))])) for { x := v.Args[0] if !(!config.use387) { @@ -11847,7 +11653,7 @@ func rewriteValue386_OpNeg64F(v *Value, config *Config) bool { } v.reset(Op386PXOR) v.AddArg(x) - v0 := b.NewValue0(v.Pos, Op386MOVSDconst, config.Frontend().TypeFloat64()) + v0 := b.NewValue0(v.Pos, Op386MOVSDconst, fe.TypeFloat64()) v0.AuxInt = f2i(math.Copysign(0, -1)) v.AddArg(v0) return true @@ -11866,9 +11672,7 @@ func rewriteValue386_OpNeg64F(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpNeg8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpNeg8(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEGL x) @@ -11879,7 +11683,7 @@ func rewriteValue386_OpNeg8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeq16(v *Value, config *Config) bool { +func rewriteValue386_OpNeq16(v *Value) bool { b := v.Block _ = b // match: (Neq16 x y) @@ -11896,7 +11700,7 @@ func rewriteValue386_OpNeq16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeq32(v *Value, config *Config) bool { +func rewriteValue386_OpNeq32(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -11913,7 +11717,7 @@ func rewriteValue386_OpNeq32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeq32F(v *Value, config *Config) bool { +func rewriteValue386_OpNeq32F(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -11930,7 +11734,7 @@ func rewriteValue386_OpNeq32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeq64F(v *Value, config *Config) bool { +func rewriteValue386_OpNeq64F(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -11947,7 +11751,7 @@ func rewriteValue386_OpNeq64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeq8(v *Value, config *Config) bool { +func rewriteValue386_OpNeq8(v *Value) bool { b := v.Block _ = b // match: (Neq8 x y) @@ -11964,7 +11768,7 @@ func rewriteValue386_OpNeq8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeqB(v *Value, config *Config) bool { +func rewriteValue386_OpNeqB(v *Value) bool { b := v.Block _ = b // match: (NeqB x y) @@ -11981,7 +11785,7 @@ func rewriteValue386_OpNeqB(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNeqPtr(v *Value, config *Config) bool { +func rewriteValue386_OpNeqPtr(v *Value) bool { b := v.Block _ = b // match: (NeqPtr x y) @@ -11998,9 +11802,7 @@ func rewriteValue386_OpNeqPtr(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNilCheck(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpNilCheck(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -12013,9 +11815,7 @@ func rewriteValue386_OpNilCheck(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpNot(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpNot(v *Value) bool { // match: (Not x) // cond: // result: (XORLconst [1] x) @@ -12027,9 +11827,7 @@ func rewriteValue386_OpNot(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpOffPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpOffPtr(v *Value) bool { // match: (OffPtr [off] ptr) // cond: // result: (ADDLconst [off] ptr) @@ -12042,9 +11840,7 @@ func rewriteValue386_OpOffPtr(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpOr16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpOr16(v *Value) bool { // match: (Or16 x y) // cond: // result: (ORL x y) @@ -12057,9 +11853,7 @@ func rewriteValue386_OpOr16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpOr32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpOr32(v *Value) bool { // match: (Or32 x y) // cond: // result: (ORL x y) @@ -12072,9 +11866,7 @@ func rewriteValue386_OpOr32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpOr8(v *Value) bool { // match: (Or8 x y) // cond: // result: (ORL x y) @@ -12087,9 +11879,7 @@ func rewriteValue386_OpOr8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpOrB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpOrB(v *Value) bool { // match: (OrB x y) // cond: // result: (ORL x y) @@ -12102,9 +11892,7 @@ func rewriteValue386_OpOrB(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpRound32F(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -12116,9 +11904,7 @@ func rewriteValue386_OpRound32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpRound64F(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -12130,7 +11916,7 @@ func rewriteValue386_OpRound64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh16Ux16(v *Value, config *Config) bool { +func rewriteValue386_OpRsh16Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux16 <t> x y) @@ -12154,7 +11940,7 @@ func rewriteValue386_OpRsh16Ux16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh16Ux32(v *Value, config *Config) bool { +func rewriteValue386_OpRsh16Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux32 <t> x y) @@ -12178,9 +11964,7 @@ func rewriteValue386_OpRsh16Ux32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh16Ux64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpRsh16Ux64(v *Value) bool { // match: (Rsh16Ux64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SHRWconst x [c]) @@ -12217,7 +12001,7 @@ func rewriteValue386_OpRsh16Ux64(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpRsh16Ux8(v *Value, config *Config) bool { +func rewriteValue386_OpRsh16Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux8 <t> x y) @@ -12241,7 +12025,7 @@ func rewriteValue386_OpRsh16Ux8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh16x16(v *Value, config *Config) bool { +func rewriteValue386_OpRsh16x16(v *Value) bool { b := v.Block _ = b // match: (Rsh16x16 <t> x y) @@ -12268,7 +12052,7 @@ func rewriteValue386_OpRsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh16x32(v *Value, config *Config) bool { +func rewriteValue386_OpRsh16x32(v *Value) bool { b := v.Block _ = b // match: (Rsh16x32 <t> x y) @@ -12295,9 +12079,7 @@ func rewriteValue386_OpRsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh16x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpRsh16x64(v *Value) bool { // match: (Rsh16x64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SARWconst x [c]) @@ -12336,7 +12118,7 @@ func rewriteValue386_OpRsh16x64(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpRsh16x8(v *Value, config *Config) bool { +func rewriteValue386_OpRsh16x8(v *Value) bool { b := v.Block _ = b // match: (Rsh16x8 <t> x y) @@ -12363,7 +12145,7 @@ func rewriteValue386_OpRsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh32Ux16(v *Value, config *Config) bool { +func rewriteValue386_OpRsh32Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux16 <t> x y) @@ -12387,7 +12169,7 @@ func rewriteValue386_OpRsh32Ux16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh32Ux32(v *Value, config *Config) bool { +func rewriteValue386_OpRsh32Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 <t> x y) @@ -12411,9 +12193,7 @@ func rewriteValue386_OpRsh32Ux32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh32Ux64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpRsh32Ux64(v *Value) bool { // match: (Rsh32Ux64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SHRLconst x [c]) @@ -12450,7 +12230,7 @@ func rewriteValue386_OpRsh32Ux64(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpRsh32Ux8(v *Value, config *Config) bool { +func rewriteValue386_OpRsh32Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux8 <t> x y) @@ -12474,7 +12254,7 @@ func rewriteValue386_OpRsh32Ux8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh32x16(v *Value, config *Config) bool { +func rewriteValue386_OpRsh32x16(v *Value) bool { b := v.Block _ = b // match: (Rsh32x16 <t> x y) @@ -12501,7 +12281,7 @@ func rewriteValue386_OpRsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh32x32(v *Value, config *Config) bool { +func rewriteValue386_OpRsh32x32(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 <t> x y) @@ -12528,9 +12308,7 @@ func rewriteValue386_OpRsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh32x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpRsh32x64(v *Value) bool { // match: (Rsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SARLconst x [c]) @@ -12569,7 +12347,7 @@ func rewriteValue386_OpRsh32x64(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpRsh32x8(v *Value, config *Config) bool { +func rewriteValue386_OpRsh32x8(v *Value) bool { b := v.Block _ = b // match: (Rsh32x8 <t> x y) @@ -12596,7 +12374,7 @@ func rewriteValue386_OpRsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh8Ux16(v *Value, config *Config) bool { +func rewriteValue386_OpRsh8Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux16 <t> x y) @@ -12620,7 +12398,7 @@ func rewriteValue386_OpRsh8Ux16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh8Ux32(v *Value, config *Config) bool { +func rewriteValue386_OpRsh8Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux32 <t> x y) @@ -12644,9 +12422,7 @@ func rewriteValue386_OpRsh8Ux32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh8Ux64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpRsh8Ux64(v *Value) bool { // match: (Rsh8Ux64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SHRBconst x [c]) @@ -12683,7 +12459,7 @@ func rewriteValue386_OpRsh8Ux64(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpRsh8Ux8(v *Value, config *Config) bool { +func rewriteValue386_OpRsh8Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux8 <t> x y) @@ -12707,7 +12483,7 @@ func rewriteValue386_OpRsh8Ux8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh8x16(v *Value, config *Config) bool { +func rewriteValue386_OpRsh8x16(v *Value) bool { b := v.Block _ = b // match: (Rsh8x16 <t> x y) @@ -12734,7 +12510,7 @@ func rewriteValue386_OpRsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh8x32(v *Value, config *Config) bool { +func rewriteValue386_OpRsh8x32(v *Value) bool { b := v.Block _ = b // match: (Rsh8x32 <t> x y) @@ -12761,9 +12537,7 @@ func rewriteValue386_OpRsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpRsh8x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpRsh8x64(v *Value) bool { // match: (Rsh8x64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SARBconst x [c]) @@ -12802,7 +12576,7 @@ func rewriteValue386_OpRsh8x64(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpRsh8x8(v *Value, config *Config) bool { +func rewriteValue386_OpRsh8x8(v *Value) bool { b := v.Block _ = b // match: (Rsh8x8 <t> x y) @@ -12829,9 +12603,7 @@ func rewriteValue386_OpRsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSignExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSignExt16to32(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVWLSX x) @@ -12842,9 +12614,7 @@ func rewriteValue386_OpSignExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSignExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSignExt8to16(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBLSX x) @@ -12855,9 +12625,7 @@ func rewriteValue386_OpSignExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSignExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSignExt8to32(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBLSX x) @@ -12868,9 +12636,7 @@ func rewriteValue386_OpSignExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSignmask(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSignmask(v *Value) bool { // match: (Signmask x) // cond: // result: (SARLconst x [31]) @@ -12882,7 +12648,7 @@ func rewriteValue386_OpSignmask(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSlicemask(v *Value, config *Config) bool { +func rewriteValue386_OpSlicemask(v *Value) bool { b := v.Block _ = b // match: (Slicemask <t> x) @@ -12899,9 +12665,7 @@ func rewriteValue386_OpSlicemask(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSqrt(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSqrt(v *Value) bool { // match: (Sqrt x) // cond: // result: (SQRTSD x) @@ -12912,9 +12676,7 @@ func rewriteValue386_OpSqrt(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpStaticCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpStaticCall(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -12929,9 +12691,7 @@ func rewriteValue386_OpStaticCall(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpStore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpStore(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type) // result: (MOVSDstore ptr val mem) @@ -13019,9 +12779,7 @@ func rewriteValue386_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpSub16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSub16(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUBL x y) @@ -13034,9 +12792,7 @@ func rewriteValue386_OpSub16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSub32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSub32(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUBL x y) @@ -13049,9 +12805,7 @@ func rewriteValue386_OpSub32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSub32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSub32F(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBSS x y) @@ -13064,9 +12818,7 @@ func rewriteValue386_OpSub32F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSub32carry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSub32carry(v *Value) bool { // match: (Sub32carry x y) // cond: // result: (SUBLcarry x y) @@ -13079,9 +12831,7 @@ func rewriteValue386_OpSub32carry(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSub32withcarry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSub32withcarry(v *Value) bool { // match: (Sub32withcarry x y c) // cond: // result: (SBBL x y c) @@ -13096,9 +12846,7 @@ func rewriteValue386_OpSub32withcarry(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSub64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSub64F(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBSD x y) @@ -13111,9 +12859,7 @@ func rewriteValue386_OpSub64F(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSub8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSub8(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUBL x y) @@ -13126,9 +12872,7 @@ func rewriteValue386_OpSub8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpSubPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpSubPtr(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUBL x y) @@ -13141,9 +12885,7 @@ func rewriteValue386_OpSubPtr(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpTrunc16to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpTrunc16to8(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -13155,9 +12897,7 @@ func rewriteValue386_OpTrunc16to8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpTrunc32to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpTrunc32to16(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -13169,9 +12909,7 @@ func rewriteValue386_OpTrunc32to16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpTrunc32to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpTrunc32to8(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -13183,9 +12921,7 @@ func rewriteValue386_OpTrunc32to8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpXor16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpXor16(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XORL x y) @@ -13198,9 +12934,7 @@ func rewriteValue386_OpXor16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpXor32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpXor32(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XORL x y) @@ -13213,9 +12947,7 @@ func rewriteValue386_OpXor32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpXor8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpXor8(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XORL x y) @@ -13228,9 +12960,13 @@ func rewriteValue386_OpXor8(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpZero(v *Value, config *Config) bool { +func rewriteValue386_OpZero(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Zero [0] _ mem) // cond: // result: mem @@ -13377,7 +13113,7 @@ func rewriteValue386_OpZero(v *Value, config *Config) bool { } v.reset(OpZero) v.AuxInt = s - s%4 - v0 := b.NewValue0(v.Pos, Op386ADDLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386ADDLconst, fe.TypeUInt32()) v0.AuxInt = s % 4 v0.AddArg(destptr) v.AddArg(v0) @@ -13470,7 +13206,7 @@ func rewriteValue386_OpZero(v *Value, config *Config) bool { v.reset(Op386DUFFZERO) v.AuxInt = 1 * (128 - s/4) v.AddArg(destptr) - v0 := b.NewValue0(v.Pos, Op386MOVLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -13488,10 +13224,10 @@ func rewriteValue386_OpZero(v *Value, config *Config) bool { } v.reset(Op386REPSTOSL) v.AddArg(destptr) - v0 := b.NewValue0(v.Pos, Op386MOVLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32()) v0.AuxInt = s / 4 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, Op386MOVLconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32()) v1.AuxInt = 0 v.AddArg(v1) v.AddArg(mem) @@ -13499,9 +13235,7 @@ func rewriteValue386_OpZero(v *Value, config *Config) bool { } return false } -func rewriteValue386_OpZeroExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpZeroExt16to32(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVWLZX x) @@ -13512,9 +13246,7 @@ func rewriteValue386_OpZeroExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpZeroExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpZeroExt8to16(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBLZX x) @@ -13525,9 +13257,7 @@ func rewriteValue386_OpZeroExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpZeroExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValue386_OpZeroExt8to32(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBLZX x) @@ -13538,7 +13268,7 @@ func rewriteValue386_OpZeroExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValue386_OpZeromask(v *Value, config *Config) bool { +func rewriteValue386_OpZeromask(v *Value) bool { b := v.Block _ = b // match: (Zeromask <t> x) @@ -13558,7 +13288,11 @@ func rewriteValue386_OpZeromask(v *Value, config *Config) bool { return true } } -func rewriteBlock386(b *Block, config *Config) bool { +func rewriteBlock386(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { case Block386EQ: // match: (EQ (InvertFlags cmp) yes no) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 76e37c29e7..548d5abfa1 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -6,830 +6,828 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValueAMD64(v *Value, config *Config) bool { +func rewriteValueAMD64(v *Value) bool { switch v.Op { case OpAMD64ADDL: - return rewriteValueAMD64_OpAMD64ADDL(v, config) + return rewriteValueAMD64_OpAMD64ADDL(v) case OpAMD64ADDLconst: - return rewriteValueAMD64_OpAMD64ADDLconst(v, config) + return rewriteValueAMD64_OpAMD64ADDLconst(v) case OpAMD64ADDQ: - return rewriteValueAMD64_OpAMD64ADDQ(v, config) + return rewriteValueAMD64_OpAMD64ADDQ(v) case OpAMD64ADDQconst: - return rewriteValueAMD64_OpAMD64ADDQconst(v, config) + return rewriteValueAMD64_OpAMD64ADDQconst(v) case OpAMD64ADDSD: - return rewriteValueAMD64_OpAMD64ADDSD(v, config) + return rewriteValueAMD64_OpAMD64ADDSD(v) case OpAMD64ADDSS: - return rewriteValueAMD64_OpAMD64ADDSS(v, config) + return rewriteValueAMD64_OpAMD64ADDSS(v) case OpAMD64ANDL: - return rewriteValueAMD64_OpAMD64ANDL(v, config) + return rewriteValueAMD64_OpAMD64ANDL(v) case OpAMD64ANDLconst: - return rewriteValueAMD64_OpAMD64ANDLconst(v, config) + return rewriteValueAMD64_OpAMD64ANDLconst(v) case OpAMD64ANDQ: - return rewriteValueAMD64_OpAMD64ANDQ(v, config) + return rewriteValueAMD64_OpAMD64ANDQ(v) case OpAMD64ANDQconst: - return rewriteValueAMD64_OpAMD64ANDQconst(v, config) + return rewriteValueAMD64_OpAMD64ANDQconst(v) case OpAMD64BSFQ: - return rewriteValueAMD64_OpAMD64BSFQ(v, config) + return rewriteValueAMD64_OpAMD64BSFQ(v) case OpAMD64BTQconst: - return rewriteValueAMD64_OpAMD64BTQconst(v, config) + return rewriteValueAMD64_OpAMD64BTQconst(v) case OpAMD64CMOVQEQ: - return rewriteValueAMD64_OpAMD64CMOVQEQ(v, config) + return rewriteValueAMD64_OpAMD64CMOVQEQ(v) case OpAMD64CMPB: - return rewriteValueAMD64_OpAMD64CMPB(v, config) + return rewriteValueAMD64_OpAMD64CMPB(v) case OpAMD64CMPBconst: - return rewriteValueAMD64_OpAMD64CMPBconst(v, config) + return rewriteValueAMD64_OpAMD64CMPBconst(v) case OpAMD64CMPL: - return rewriteValueAMD64_OpAMD64CMPL(v, config) + return rewriteValueAMD64_OpAMD64CMPL(v) case OpAMD64CMPLconst: - return rewriteValueAMD64_OpAMD64CMPLconst(v, config) + return rewriteValueAMD64_OpAMD64CMPLconst(v) case OpAMD64CMPQ: - return rewriteValueAMD64_OpAMD64CMPQ(v, config) + return rewriteValueAMD64_OpAMD64CMPQ(v) case OpAMD64CMPQconst: - return rewriteValueAMD64_OpAMD64CMPQconst(v, config) + return rewriteValueAMD64_OpAMD64CMPQconst(v) case OpAMD64CMPW: - return rewriteValueAMD64_OpAMD64CMPW(v, config) + return rewriteValueAMD64_OpAMD64CMPW(v) case OpAMD64CMPWconst: - return rewriteValueAMD64_OpAMD64CMPWconst(v, config) + return rewriteValueAMD64_OpAMD64CMPWconst(v) case OpAMD64CMPXCHGLlock: - return rewriteValueAMD64_OpAMD64CMPXCHGLlock(v, config) + return rewriteValueAMD64_OpAMD64CMPXCHGLlock(v) case OpAMD64CMPXCHGQlock: - return rewriteValueAMD64_OpAMD64CMPXCHGQlock(v, config) + return rewriteValueAMD64_OpAMD64CMPXCHGQlock(v) case OpAMD64LEAL: - return rewriteValueAMD64_OpAMD64LEAL(v, config) + return rewriteValueAMD64_OpAMD64LEAL(v) case OpAMD64LEAQ: - return rewriteValueAMD64_OpAMD64LEAQ(v, config) + return rewriteValueAMD64_OpAMD64LEAQ(v) case OpAMD64LEAQ1: - return rewriteValueAMD64_OpAMD64LEAQ1(v, config) + return rewriteValueAMD64_OpAMD64LEAQ1(v) case OpAMD64LEAQ2: - return rewriteValueAMD64_OpAMD64LEAQ2(v, config) + return rewriteValueAMD64_OpAMD64LEAQ2(v) case OpAMD64LEAQ4: - return rewriteValueAMD64_OpAMD64LEAQ4(v, config) + return rewriteValueAMD64_OpAMD64LEAQ4(v) case OpAMD64LEAQ8: - return rewriteValueAMD64_OpAMD64LEAQ8(v, config) + return rewriteValueAMD64_OpAMD64LEAQ8(v) case OpAMD64MOVBQSX: - return rewriteValueAMD64_OpAMD64MOVBQSX(v, config) + return rewriteValueAMD64_OpAMD64MOVBQSX(v) case OpAMD64MOVBQSXload: - return rewriteValueAMD64_OpAMD64MOVBQSXload(v, config) + return rewriteValueAMD64_OpAMD64MOVBQSXload(v) case OpAMD64MOVBQZX: - return rewriteValueAMD64_OpAMD64MOVBQZX(v, config) + return rewriteValueAMD64_OpAMD64MOVBQZX(v) case OpAMD64MOVBload: - return rewriteValueAMD64_OpAMD64MOVBload(v, config) + return rewriteValueAMD64_OpAMD64MOVBload(v) case OpAMD64MOVBloadidx1: - return rewriteValueAMD64_OpAMD64MOVBloadidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVBloadidx1(v) case OpAMD64MOVBstore: - return rewriteValueAMD64_OpAMD64MOVBstore(v, config) + return rewriteValueAMD64_OpAMD64MOVBstore(v) case OpAMD64MOVBstoreconst: - return rewriteValueAMD64_OpAMD64MOVBstoreconst(v, config) + return rewriteValueAMD64_OpAMD64MOVBstoreconst(v) case OpAMD64MOVBstoreconstidx1: - return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v) case OpAMD64MOVBstoreidx1: - return rewriteValueAMD64_OpAMD64MOVBstoreidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVBstoreidx1(v) case OpAMD64MOVLQSX: - return rewriteValueAMD64_OpAMD64MOVLQSX(v, config) + return rewriteValueAMD64_OpAMD64MOVLQSX(v) case OpAMD64MOVLQSXload: - return rewriteValueAMD64_OpAMD64MOVLQSXload(v, config) + return rewriteValueAMD64_OpAMD64MOVLQSXload(v) case OpAMD64MOVLQZX: - return rewriteValueAMD64_OpAMD64MOVLQZX(v, config) + return rewriteValueAMD64_OpAMD64MOVLQZX(v) case OpAMD64MOVLatomicload: - return rewriteValueAMD64_OpAMD64MOVLatomicload(v, config) + return rewriteValueAMD64_OpAMD64MOVLatomicload(v) case OpAMD64MOVLload: - return rewriteValueAMD64_OpAMD64MOVLload(v, config) + return rewriteValueAMD64_OpAMD64MOVLload(v) case OpAMD64MOVLloadidx1: - return rewriteValueAMD64_OpAMD64MOVLloadidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVLloadidx1(v) case OpAMD64MOVLloadidx4: - return rewriteValueAMD64_OpAMD64MOVLloadidx4(v, config) + return rewriteValueAMD64_OpAMD64MOVLloadidx4(v) case OpAMD64MOVLstore: - return rewriteValueAMD64_OpAMD64MOVLstore(v, config) + return rewriteValueAMD64_OpAMD64MOVLstore(v) case OpAMD64MOVLstoreconst: - return rewriteValueAMD64_OpAMD64MOVLstoreconst(v, config) + return rewriteValueAMD64_OpAMD64MOVLstoreconst(v) case OpAMD64MOVLstoreconstidx1: - return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v) case OpAMD64MOVLstoreconstidx4: - return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v, config) + return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v) case OpAMD64MOVLstoreidx1: - return rewriteValueAMD64_OpAMD64MOVLstoreidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVLstoreidx1(v) case OpAMD64MOVLstoreidx4: - return rewriteValueAMD64_OpAMD64MOVLstoreidx4(v, config) + return rewriteValueAMD64_OpAMD64MOVLstoreidx4(v) case OpAMD64MOVOload: - return rewriteValueAMD64_OpAMD64MOVOload(v, config) + return rewriteValueAMD64_OpAMD64MOVOload(v) case OpAMD64MOVOstore: - return rewriteValueAMD64_OpAMD64MOVOstore(v, config) + return rewriteValueAMD64_OpAMD64MOVOstore(v) case OpAMD64MOVQatomicload: - return rewriteValueAMD64_OpAMD64MOVQatomicload(v, config) + return rewriteValueAMD64_OpAMD64MOVQatomicload(v) case OpAMD64MOVQload: - return rewriteValueAMD64_OpAMD64MOVQload(v, config) + return rewriteValueAMD64_OpAMD64MOVQload(v) case OpAMD64MOVQloadidx1: - return rewriteValueAMD64_OpAMD64MOVQloadidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVQloadidx1(v) case OpAMD64MOVQloadidx8: - return rewriteValueAMD64_OpAMD64MOVQloadidx8(v, config) + return rewriteValueAMD64_OpAMD64MOVQloadidx8(v) case OpAMD64MOVQstore: - return rewriteValueAMD64_OpAMD64MOVQstore(v, config) + return rewriteValueAMD64_OpAMD64MOVQstore(v) case OpAMD64MOVQstoreconst: - return rewriteValueAMD64_OpAMD64MOVQstoreconst(v, config) + return rewriteValueAMD64_OpAMD64MOVQstoreconst(v) case OpAMD64MOVQstoreconstidx1: - return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v) case OpAMD64MOVQstoreconstidx8: - return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v, config) + return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v) case OpAMD64MOVQstoreidx1: - return rewriteValueAMD64_OpAMD64MOVQstoreidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVQstoreidx1(v) case OpAMD64MOVQstoreidx8: - return rewriteValueAMD64_OpAMD64MOVQstoreidx8(v, config) + return rewriteValueAMD64_OpAMD64MOVQstoreidx8(v) case OpAMD64MOVSDload: - return rewriteValueAMD64_OpAMD64MOVSDload(v, config) + return rewriteValueAMD64_OpAMD64MOVSDload(v) case OpAMD64MOVSDloadidx1: - return rewriteValueAMD64_OpAMD64MOVSDloadidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVSDloadidx1(v) case OpAMD64MOVSDloadidx8: - return rewriteValueAMD64_OpAMD64MOVSDloadidx8(v, config) + return rewriteValueAMD64_OpAMD64MOVSDloadidx8(v) case OpAMD64MOVSDstore: - return rewriteValueAMD64_OpAMD64MOVSDstore(v, config) + return rewriteValueAMD64_OpAMD64MOVSDstore(v) case OpAMD64MOVSDstoreidx1: - return rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v) case OpAMD64MOVSDstoreidx8: - return rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v, config) + return rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v) case OpAMD64MOVSSload: - return rewriteValueAMD64_OpAMD64MOVSSload(v, config) + return rewriteValueAMD64_OpAMD64MOVSSload(v) case OpAMD64MOVSSloadidx1: - return rewriteValueAMD64_OpAMD64MOVSSloadidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVSSloadidx1(v) case OpAMD64MOVSSloadidx4: - return rewriteValueAMD64_OpAMD64MOVSSloadidx4(v, config) + return rewriteValueAMD64_OpAMD64MOVSSloadidx4(v) case OpAMD64MOVSSstore: - return rewriteValueAMD64_OpAMD64MOVSSstore(v, config) + return rewriteValueAMD64_OpAMD64MOVSSstore(v) case OpAMD64MOVSSstoreidx1: - return rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v) case OpAMD64MOVSSstoreidx4: - return rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v, config) + return rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v) case OpAMD64MOVWQSX: - return rewriteValueAMD64_OpAMD64MOVWQSX(v, config) + return rewriteValueAMD64_OpAMD64MOVWQSX(v) case OpAMD64MOVWQSXload: - return rewriteValueAMD64_OpAMD64MOVWQSXload(v, config) + return rewriteValueAMD64_OpAMD64MOVWQSXload(v) case OpAMD64MOVWQZX: - return rewriteValueAMD64_OpAMD64MOVWQZX(v, config) + return rewriteValueAMD64_OpAMD64MOVWQZX(v) case OpAMD64MOVWload: - return rewriteValueAMD64_OpAMD64MOVWload(v, config) + return rewriteValueAMD64_OpAMD64MOVWload(v) case OpAMD64MOVWloadidx1: - return rewriteValueAMD64_OpAMD64MOVWloadidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVWloadidx1(v) case OpAMD64MOVWloadidx2: - return rewriteValueAMD64_OpAMD64MOVWloadidx2(v, config) + return rewriteValueAMD64_OpAMD64MOVWloadidx2(v) case OpAMD64MOVWstore: - return rewriteValueAMD64_OpAMD64MOVWstore(v, config) + return rewriteValueAMD64_OpAMD64MOVWstore(v) case OpAMD64MOVWstoreconst: - return rewriteValueAMD64_OpAMD64MOVWstoreconst(v, config) + return rewriteValueAMD64_OpAMD64MOVWstoreconst(v) case OpAMD64MOVWstoreconstidx1: - return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v) case OpAMD64MOVWstoreconstidx2: - return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v, config) + return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v) case OpAMD64MOVWstoreidx1: - return rewriteValueAMD64_OpAMD64MOVWstoreidx1(v, config) + return rewriteValueAMD64_OpAMD64MOVWstoreidx1(v) case OpAMD64MOVWstoreidx2: - return rewriteValueAMD64_OpAMD64MOVWstoreidx2(v, config) + return rewriteValueAMD64_OpAMD64MOVWstoreidx2(v) case OpAMD64MULL: - return rewriteValueAMD64_OpAMD64MULL(v, config) + return rewriteValueAMD64_OpAMD64MULL(v) case OpAMD64MULLconst: - return rewriteValueAMD64_OpAMD64MULLconst(v, config) + return rewriteValueAMD64_OpAMD64MULLconst(v) case OpAMD64MULQ: - return rewriteValueAMD64_OpAMD64MULQ(v, config) + return rewriteValueAMD64_OpAMD64MULQ(v) case OpAMD64MULQconst: - return rewriteValueAMD64_OpAMD64MULQconst(v, config) + return rewriteValueAMD64_OpAMD64MULQconst(v) case OpAMD64MULSD: - return rewriteValueAMD64_OpAMD64MULSD(v, config) + return rewriteValueAMD64_OpAMD64MULSD(v) case OpAMD64MULSS: - return rewriteValueAMD64_OpAMD64MULSS(v, config) + return rewriteValueAMD64_OpAMD64MULSS(v) case OpAMD64NEGL: - return rewriteValueAMD64_OpAMD64NEGL(v, config) + return rewriteValueAMD64_OpAMD64NEGL(v) case OpAMD64NEGQ: - return rewriteValueAMD64_OpAMD64NEGQ(v, config) + return rewriteValueAMD64_OpAMD64NEGQ(v) case OpAMD64NOTL: - return rewriteValueAMD64_OpAMD64NOTL(v, config) + return rewriteValueAMD64_OpAMD64NOTL(v) case OpAMD64NOTQ: - return rewriteValueAMD64_OpAMD64NOTQ(v, config) + return rewriteValueAMD64_OpAMD64NOTQ(v) case OpAMD64ORL: - return rewriteValueAMD64_OpAMD64ORL(v, config) + return rewriteValueAMD64_OpAMD64ORL(v) case OpAMD64ORLconst: - return rewriteValueAMD64_OpAMD64ORLconst(v, config) + return rewriteValueAMD64_OpAMD64ORLconst(v) case OpAMD64ORQ: - return rewriteValueAMD64_OpAMD64ORQ(v, config) + return rewriteValueAMD64_OpAMD64ORQ(v) case OpAMD64ORQconst: - return rewriteValueAMD64_OpAMD64ORQconst(v, config) + return rewriteValueAMD64_OpAMD64ORQconst(v) case OpAMD64ROLBconst: - return rewriteValueAMD64_OpAMD64ROLBconst(v, config) + return rewriteValueAMD64_OpAMD64ROLBconst(v) case OpAMD64ROLLconst: - return rewriteValueAMD64_OpAMD64ROLLconst(v, config) + return rewriteValueAMD64_OpAMD64ROLLconst(v) case OpAMD64ROLQconst: - return rewriteValueAMD64_OpAMD64ROLQconst(v, config) + return rewriteValueAMD64_OpAMD64ROLQconst(v) case OpAMD64ROLWconst: - return rewriteValueAMD64_OpAMD64ROLWconst(v, config) + return rewriteValueAMD64_OpAMD64ROLWconst(v) case OpAMD64SARB: - return rewriteValueAMD64_OpAMD64SARB(v, config) + return rewriteValueAMD64_OpAMD64SARB(v) case OpAMD64SARBconst: - return rewriteValueAMD64_OpAMD64SARBconst(v, config) + return rewriteValueAMD64_OpAMD64SARBconst(v) case OpAMD64SARL: - return rewriteValueAMD64_OpAMD64SARL(v, config) + return rewriteValueAMD64_OpAMD64SARL(v) case OpAMD64SARLconst: - return rewriteValueAMD64_OpAMD64SARLconst(v, config) + return rewriteValueAMD64_OpAMD64SARLconst(v) case OpAMD64SARQ: - return rewriteValueAMD64_OpAMD64SARQ(v, config) + return rewriteValueAMD64_OpAMD64SARQ(v) case OpAMD64SARQconst: - return rewriteValueAMD64_OpAMD64SARQconst(v, config) + return rewriteValueAMD64_OpAMD64SARQconst(v) case OpAMD64SARW: - return rewriteValueAMD64_OpAMD64SARW(v, config) + return rewriteValueAMD64_OpAMD64SARW(v) case OpAMD64SARWconst: - return rewriteValueAMD64_OpAMD64SARWconst(v, config) + return rewriteValueAMD64_OpAMD64SARWconst(v) case OpAMD64SBBLcarrymask: - return rewriteValueAMD64_OpAMD64SBBLcarrymask(v, config) + return rewriteValueAMD64_OpAMD64SBBLcarrymask(v) case OpAMD64SBBQcarrymask: - return rewriteValueAMD64_OpAMD64SBBQcarrymask(v, config) + return rewriteValueAMD64_OpAMD64SBBQcarrymask(v) case OpAMD64SETA: - return rewriteValueAMD64_OpAMD64SETA(v, config) + return rewriteValueAMD64_OpAMD64SETA(v) case OpAMD64SETAE: - return rewriteValueAMD64_OpAMD64SETAE(v, config) + return rewriteValueAMD64_OpAMD64SETAE(v) case OpAMD64SETB: - return rewriteValueAMD64_OpAMD64SETB(v, config) + return rewriteValueAMD64_OpAMD64SETB(v) case OpAMD64SETBE: - return rewriteValueAMD64_OpAMD64SETBE(v, config) + return rewriteValueAMD64_OpAMD64SETBE(v) case OpAMD64SETEQ: - return rewriteValueAMD64_OpAMD64SETEQ(v, config) + return rewriteValueAMD64_OpAMD64SETEQ(v) case OpAMD64SETG: - return rewriteValueAMD64_OpAMD64SETG(v, config) + return rewriteValueAMD64_OpAMD64SETG(v) case OpAMD64SETGE: - return rewriteValueAMD64_OpAMD64SETGE(v, config) + return rewriteValueAMD64_OpAMD64SETGE(v) case OpAMD64SETL: - return rewriteValueAMD64_OpAMD64SETL(v, config) + return rewriteValueAMD64_OpAMD64SETL(v) case OpAMD64SETLE: - return rewriteValueAMD64_OpAMD64SETLE(v, config) + return rewriteValueAMD64_OpAMD64SETLE(v) case OpAMD64SETNE: - return rewriteValueAMD64_OpAMD64SETNE(v, config) + return rewriteValueAMD64_OpAMD64SETNE(v) case OpAMD64SHLL: - return rewriteValueAMD64_OpAMD64SHLL(v, config) + return rewriteValueAMD64_OpAMD64SHLL(v) case OpAMD64SHLLconst: - return rewriteValueAMD64_OpAMD64SHLLconst(v, config) + return rewriteValueAMD64_OpAMD64SHLLconst(v) case OpAMD64SHLQ: - return rewriteValueAMD64_OpAMD64SHLQ(v, config) + return rewriteValueAMD64_OpAMD64SHLQ(v) case OpAMD64SHLQconst: - return rewriteValueAMD64_OpAMD64SHLQconst(v, config) + return rewriteValueAMD64_OpAMD64SHLQconst(v) case OpAMD64SHRB: - return rewriteValueAMD64_OpAMD64SHRB(v, config) + return rewriteValueAMD64_OpAMD64SHRB(v) case OpAMD64SHRBconst: - return rewriteValueAMD64_OpAMD64SHRBconst(v, config) + return rewriteValueAMD64_OpAMD64SHRBconst(v) case OpAMD64SHRL: - return rewriteValueAMD64_OpAMD64SHRL(v, config) + return rewriteValueAMD64_OpAMD64SHRL(v) case OpAMD64SHRLconst: - return rewriteValueAMD64_OpAMD64SHRLconst(v, config) + return rewriteValueAMD64_OpAMD64SHRLconst(v) case OpAMD64SHRQ: - return rewriteValueAMD64_OpAMD64SHRQ(v, config) + return rewriteValueAMD64_OpAMD64SHRQ(v) case OpAMD64SHRQconst: - return rewriteValueAMD64_OpAMD64SHRQconst(v, config) + return rewriteValueAMD64_OpAMD64SHRQconst(v) case OpAMD64SHRW: - return rewriteValueAMD64_OpAMD64SHRW(v, config) + return rewriteValueAMD64_OpAMD64SHRW(v) case OpAMD64SHRWconst: - return rewriteValueAMD64_OpAMD64SHRWconst(v, config) + return rewriteValueAMD64_OpAMD64SHRWconst(v) case OpAMD64SUBL: - return rewriteValueAMD64_OpAMD64SUBL(v, config) + return rewriteValueAMD64_OpAMD64SUBL(v) case OpAMD64SUBLconst: - return rewriteValueAMD64_OpAMD64SUBLconst(v, config) + return rewriteValueAMD64_OpAMD64SUBLconst(v) case OpAMD64SUBQ: - return rewriteValueAMD64_OpAMD64SUBQ(v, config) + return rewriteValueAMD64_OpAMD64SUBQ(v) case OpAMD64SUBQconst: - return rewriteValueAMD64_OpAMD64SUBQconst(v, config) + return rewriteValueAMD64_OpAMD64SUBQconst(v) case OpAMD64SUBSD: - return rewriteValueAMD64_OpAMD64SUBSD(v, config) + return rewriteValueAMD64_OpAMD64SUBSD(v) case OpAMD64SUBSS: - return rewriteValueAMD64_OpAMD64SUBSS(v, config) + return rewriteValueAMD64_OpAMD64SUBSS(v) case OpAMD64TESTB: - return rewriteValueAMD64_OpAMD64TESTB(v, config) + return rewriteValueAMD64_OpAMD64TESTB(v) case OpAMD64TESTL: - return rewriteValueAMD64_OpAMD64TESTL(v, config) + return rewriteValueAMD64_OpAMD64TESTL(v) case OpAMD64TESTQ: - return rewriteValueAMD64_OpAMD64TESTQ(v, config) + return rewriteValueAMD64_OpAMD64TESTQ(v) case OpAMD64TESTW: - return rewriteValueAMD64_OpAMD64TESTW(v, config) + return rewriteValueAMD64_OpAMD64TESTW(v) case OpAMD64XADDLlock: - return rewriteValueAMD64_OpAMD64XADDLlock(v, config) + return rewriteValueAMD64_OpAMD64XADDLlock(v) case OpAMD64XADDQlock: - return rewriteValueAMD64_OpAMD64XADDQlock(v, config) + return rewriteValueAMD64_OpAMD64XADDQlock(v) case OpAMD64XCHGL: - return rewriteValueAMD64_OpAMD64XCHGL(v, config) + return rewriteValueAMD64_OpAMD64XCHGL(v) case OpAMD64XCHGQ: - return rewriteValueAMD64_OpAMD64XCHGQ(v, config) + return rewriteValueAMD64_OpAMD64XCHGQ(v) case OpAMD64XORL: - return rewriteValueAMD64_OpAMD64XORL(v, config) + return rewriteValueAMD64_OpAMD64XORL(v) case OpAMD64XORLconst: - return rewriteValueAMD64_OpAMD64XORLconst(v, config) + return rewriteValueAMD64_OpAMD64XORLconst(v) case OpAMD64XORQ: - return rewriteValueAMD64_OpAMD64XORQ(v, config) + return rewriteValueAMD64_OpAMD64XORQ(v) case OpAMD64XORQconst: - return rewriteValueAMD64_OpAMD64XORQconst(v, config) + return rewriteValueAMD64_OpAMD64XORQconst(v) case OpAdd16: - return rewriteValueAMD64_OpAdd16(v, config) + return rewriteValueAMD64_OpAdd16(v) case OpAdd32: - return rewriteValueAMD64_OpAdd32(v, config) + return rewriteValueAMD64_OpAdd32(v) case OpAdd32F: - return rewriteValueAMD64_OpAdd32F(v, config) + return rewriteValueAMD64_OpAdd32F(v) case OpAdd64: - return rewriteValueAMD64_OpAdd64(v, config) + return rewriteValueAMD64_OpAdd64(v) case OpAdd64F: - return rewriteValueAMD64_OpAdd64F(v, config) + return rewriteValueAMD64_OpAdd64F(v) case OpAdd8: - return rewriteValueAMD64_OpAdd8(v, config) + return rewriteValueAMD64_OpAdd8(v) case OpAddPtr: - return rewriteValueAMD64_OpAddPtr(v, config) + return rewriteValueAMD64_OpAddPtr(v) case OpAddr: - return rewriteValueAMD64_OpAddr(v, config) + return rewriteValueAMD64_OpAddr(v) case OpAnd16: - return rewriteValueAMD64_OpAnd16(v, config) + return rewriteValueAMD64_OpAnd16(v) case OpAnd32: - return rewriteValueAMD64_OpAnd32(v, config) + return rewriteValueAMD64_OpAnd32(v) case OpAnd64: - return rewriteValueAMD64_OpAnd64(v, config) + return rewriteValueAMD64_OpAnd64(v) case OpAnd8: - return rewriteValueAMD64_OpAnd8(v, config) + return rewriteValueAMD64_OpAnd8(v) case OpAndB: - return rewriteValueAMD64_OpAndB(v, config) + return rewriteValueAMD64_OpAndB(v) case OpAtomicAdd32: - return rewriteValueAMD64_OpAtomicAdd32(v, config) + return rewriteValueAMD64_OpAtomicAdd32(v) case OpAtomicAdd64: - return rewriteValueAMD64_OpAtomicAdd64(v, config) + return rewriteValueAMD64_OpAtomicAdd64(v) case OpAtomicAnd8: - return rewriteValueAMD64_OpAtomicAnd8(v, config) + return rewriteValueAMD64_OpAtomicAnd8(v) case OpAtomicCompareAndSwap32: - return rewriteValueAMD64_OpAtomicCompareAndSwap32(v, config) + return rewriteValueAMD64_OpAtomicCompareAndSwap32(v) case OpAtomicCompareAndSwap64: - return rewriteValueAMD64_OpAtomicCompareAndSwap64(v, config) + return rewriteValueAMD64_OpAtomicCompareAndSwap64(v) case OpAtomicExchange32: - return rewriteValueAMD64_OpAtomicExchange32(v, config) + return rewriteValueAMD64_OpAtomicExchange32(v) case OpAtomicExchange64: - return rewriteValueAMD64_OpAtomicExchange64(v, config) + return rewriteValueAMD64_OpAtomicExchange64(v) case OpAtomicLoad32: - return rewriteValueAMD64_OpAtomicLoad32(v, config) + return rewriteValueAMD64_OpAtomicLoad32(v) case OpAtomicLoad64: - return rewriteValueAMD64_OpAtomicLoad64(v, config) + return rewriteValueAMD64_OpAtomicLoad64(v) case OpAtomicLoadPtr: - return rewriteValueAMD64_OpAtomicLoadPtr(v, config) + return rewriteValueAMD64_OpAtomicLoadPtr(v) case OpAtomicOr8: - return rewriteValueAMD64_OpAtomicOr8(v, config) + return rewriteValueAMD64_OpAtomicOr8(v) case OpAtomicStore32: - return rewriteValueAMD64_OpAtomicStore32(v, config) + return rewriteValueAMD64_OpAtomicStore32(v) case OpAtomicStore64: - return rewriteValueAMD64_OpAtomicStore64(v, config) + return rewriteValueAMD64_OpAtomicStore64(v) case OpAtomicStorePtrNoWB: - return rewriteValueAMD64_OpAtomicStorePtrNoWB(v, config) + return rewriteValueAMD64_OpAtomicStorePtrNoWB(v) case OpAvg64u: - return rewriteValueAMD64_OpAvg64u(v, config) + return rewriteValueAMD64_OpAvg64u(v) case OpBitLen32: - return rewriteValueAMD64_OpBitLen32(v, config) + return rewriteValueAMD64_OpBitLen32(v) case OpBitLen64: - return rewriteValueAMD64_OpBitLen64(v, config) + return rewriteValueAMD64_OpBitLen64(v) case OpBswap32: - return rewriteValueAMD64_OpBswap32(v, config) + return rewriteValueAMD64_OpBswap32(v) case OpBswap64: - return rewriteValueAMD64_OpBswap64(v, config) + return rewriteValueAMD64_OpBswap64(v) case OpClosureCall: - return rewriteValueAMD64_OpClosureCall(v, config) + return rewriteValueAMD64_OpClosureCall(v) case OpCom16: - return rewriteValueAMD64_OpCom16(v, config) + return rewriteValueAMD64_OpCom16(v) case OpCom32: - return rewriteValueAMD64_OpCom32(v, config) + return rewriteValueAMD64_OpCom32(v) case OpCom64: - return rewriteValueAMD64_OpCom64(v, config) + return rewriteValueAMD64_OpCom64(v) case OpCom8: - return rewriteValueAMD64_OpCom8(v, config) + return rewriteValueAMD64_OpCom8(v) case OpConst16: - return rewriteValueAMD64_OpConst16(v, config) + return rewriteValueAMD64_OpConst16(v) case OpConst32: - return rewriteValueAMD64_OpConst32(v, config) + return rewriteValueAMD64_OpConst32(v) case OpConst32F: - return rewriteValueAMD64_OpConst32F(v, config) + return rewriteValueAMD64_OpConst32F(v) case OpConst64: - return rewriteValueAMD64_OpConst64(v, config) + return rewriteValueAMD64_OpConst64(v) case OpConst64F: - return rewriteValueAMD64_OpConst64F(v, config) + return rewriteValueAMD64_OpConst64F(v) case OpConst8: - return rewriteValueAMD64_OpConst8(v, config) + return rewriteValueAMD64_OpConst8(v) case OpConstBool: - return rewriteValueAMD64_OpConstBool(v, config) + return rewriteValueAMD64_OpConstBool(v) case OpConstNil: - return rewriteValueAMD64_OpConstNil(v, config) + return rewriteValueAMD64_OpConstNil(v) case OpConvert: - return rewriteValueAMD64_OpConvert(v, config) + return rewriteValueAMD64_OpConvert(v) case OpCtz32: - return rewriteValueAMD64_OpCtz32(v, config) + return rewriteValueAMD64_OpCtz32(v) case OpCtz64: - return rewriteValueAMD64_OpCtz64(v, config) + return rewriteValueAMD64_OpCtz64(v) case OpCvt32Fto32: - return rewriteValueAMD64_OpCvt32Fto32(v, config) + return rewriteValueAMD64_OpCvt32Fto32(v) case OpCvt32Fto64: - return rewriteValueAMD64_OpCvt32Fto64(v, config) + return rewriteValueAMD64_OpCvt32Fto64(v) case OpCvt32Fto64F: - return rewriteValueAMD64_OpCvt32Fto64F(v, config) + return rewriteValueAMD64_OpCvt32Fto64F(v) case OpCvt32to32F: - return rewriteValueAMD64_OpCvt32to32F(v, config) + return rewriteValueAMD64_OpCvt32to32F(v) case OpCvt32to64F: - return rewriteValueAMD64_OpCvt32to64F(v, config) + return rewriteValueAMD64_OpCvt32to64F(v) case OpCvt64Fto32: - return rewriteValueAMD64_OpCvt64Fto32(v, config) + return rewriteValueAMD64_OpCvt64Fto32(v) case OpCvt64Fto32F: - return rewriteValueAMD64_OpCvt64Fto32F(v, config) + return rewriteValueAMD64_OpCvt64Fto32F(v) case OpCvt64Fto64: - return rewriteValueAMD64_OpCvt64Fto64(v, config) + return rewriteValueAMD64_OpCvt64Fto64(v) case OpCvt64to32F: - return rewriteValueAMD64_OpCvt64to32F(v, config) + return rewriteValueAMD64_OpCvt64to32F(v) case OpCvt64to64F: - return rewriteValueAMD64_OpCvt64to64F(v, config) + return rewriteValueAMD64_OpCvt64to64F(v) case OpDiv128u: - return rewriteValueAMD64_OpDiv128u(v, config) + return rewriteValueAMD64_OpDiv128u(v) case OpDiv16: - return rewriteValueAMD64_OpDiv16(v, config) + return rewriteValueAMD64_OpDiv16(v) case OpDiv16u: - return rewriteValueAMD64_OpDiv16u(v, config) + return rewriteValueAMD64_OpDiv16u(v) case OpDiv32: - return rewriteValueAMD64_OpDiv32(v, config) + return rewriteValueAMD64_OpDiv32(v) case OpDiv32F: - return rewriteValueAMD64_OpDiv32F(v, config) + return rewriteValueAMD64_OpDiv32F(v) case OpDiv32u: - return rewriteValueAMD64_OpDiv32u(v, config) + return rewriteValueAMD64_OpDiv32u(v) case OpDiv64: - return rewriteValueAMD64_OpDiv64(v, config) + return rewriteValueAMD64_OpDiv64(v) case OpDiv64F: - return rewriteValueAMD64_OpDiv64F(v, config) + return rewriteValueAMD64_OpDiv64F(v) case OpDiv64u: - return rewriteValueAMD64_OpDiv64u(v, config) + return rewriteValueAMD64_OpDiv64u(v) case OpDiv8: - return rewriteValueAMD64_OpDiv8(v, config) + return rewriteValueAMD64_OpDiv8(v) case OpDiv8u: - return rewriteValueAMD64_OpDiv8u(v, config) + return rewriteValueAMD64_OpDiv8u(v) case OpEq16: - return rewriteValueAMD64_OpEq16(v, config) + return rewriteValueAMD64_OpEq16(v) case OpEq32: - return rewriteValueAMD64_OpEq32(v, config) + return rewriteValueAMD64_OpEq32(v) case OpEq32F: - return rewriteValueAMD64_OpEq32F(v, config) + return rewriteValueAMD64_OpEq32F(v) case OpEq64: - return rewriteValueAMD64_OpEq64(v, config) + return rewriteValueAMD64_OpEq64(v) case OpEq64F: - return rewriteValueAMD64_OpEq64F(v, config) + return rewriteValueAMD64_OpEq64F(v) case OpEq8: - return rewriteValueAMD64_OpEq8(v, config) + return rewriteValueAMD64_OpEq8(v) case OpEqB: - return rewriteValueAMD64_OpEqB(v, config) + return rewriteValueAMD64_OpEqB(v) case OpEqPtr: - return rewriteValueAMD64_OpEqPtr(v, config) + return rewriteValueAMD64_OpEqPtr(v) case OpGeq16: - return rewriteValueAMD64_OpGeq16(v, config) + return rewriteValueAMD64_OpGeq16(v) case OpGeq16U: - return rewriteValueAMD64_OpGeq16U(v, config) + return rewriteValueAMD64_OpGeq16U(v) case OpGeq32: - return rewriteValueAMD64_OpGeq32(v, config) + return rewriteValueAMD64_OpGeq32(v) case OpGeq32F: - return rewriteValueAMD64_OpGeq32F(v, config) + return rewriteValueAMD64_OpGeq32F(v) case OpGeq32U: - return rewriteValueAMD64_OpGeq32U(v, config) + return rewriteValueAMD64_OpGeq32U(v) case OpGeq64: - return rewriteValueAMD64_OpGeq64(v, config) + return rewriteValueAMD64_OpGeq64(v) case OpGeq64F: - return rewriteValueAMD64_OpGeq64F(v, config) + return rewriteValueAMD64_OpGeq64F(v) case OpGeq64U: - return rewriteValueAMD64_OpGeq64U(v, config) + return rewriteValueAMD64_OpGeq64U(v) case OpGeq8: - return rewriteValueAMD64_OpGeq8(v, config) + return rewriteValueAMD64_OpGeq8(v) case OpGeq8U: - return rewriteValueAMD64_OpGeq8U(v, config) + return rewriteValueAMD64_OpGeq8U(v) case OpGetClosurePtr: - return rewriteValueAMD64_OpGetClosurePtr(v, config) + return rewriteValueAMD64_OpGetClosurePtr(v) case OpGetG: - return rewriteValueAMD64_OpGetG(v, config) + return rewriteValueAMD64_OpGetG(v) case OpGreater16: - return rewriteValueAMD64_OpGreater16(v, config) + return rewriteValueAMD64_OpGreater16(v) case OpGreater16U: - return rewriteValueAMD64_OpGreater16U(v, config) + return rewriteValueAMD64_OpGreater16U(v) case OpGreater32: - return rewriteValueAMD64_OpGreater32(v, config) + return rewriteValueAMD64_OpGreater32(v) case OpGreater32F: - return rewriteValueAMD64_OpGreater32F(v, config) + return rewriteValueAMD64_OpGreater32F(v) case OpGreater32U: - return rewriteValueAMD64_OpGreater32U(v, config) + return rewriteValueAMD64_OpGreater32U(v) case OpGreater64: - return rewriteValueAMD64_OpGreater64(v, config) + return rewriteValueAMD64_OpGreater64(v) case OpGreater64F: - return rewriteValueAMD64_OpGreater64F(v, config) + return rewriteValueAMD64_OpGreater64F(v) case OpGreater64U: - return rewriteValueAMD64_OpGreater64U(v, config) + return rewriteValueAMD64_OpGreater64U(v) case OpGreater8: - return rewriteValueAMD64_OpGreater8(v, config) + return rewriteValueAMD64_OpGreater8(v) case OpGreater8U: - return rewriteValueAMD64_OpGreater8U(v, config) + return rewriteValueAMD64_OpGreater8U(v) case OpHmul32: - return rewriteValueAMD64_OpHmul32(v, config) + return rewriteValueAMD64_OpHmul32(v) case OpHmul32u: - return rewriteValueAMD64_OpHmul32u(v, config) + return rewriteValueAMD64_OpHmul32u(v) case OpHmul64: - return rewriteValueAMD64_OpHmul64(v, config) + return rewriteValueAMD64_OpHmul64(v) case OpHmul64u: - return rewriteValueAMD64_OpHmul64u(v, config) + return rewriteValueAMD64_OpHmul64u(v) case OpInt64Hi: - return rewriteValueAMD64_OpInt64Hi(v, config) + return rewriteValueAMD64_OpInt64Hi(v) case OpInterCall: - return rewriteValueAMD64_OpInterCall(v, config) + return rewriteValueAMD64_OpInterCall(v) case OpIsInBounds: - return rewriteValueAMD64_OpIsInBounds(v, config) + return rewriteValueAMD64_OpIsInBounds(v) case OpIsNonNil: - return rewriteValueAMD64_OpIsNonNil(v, config) + return rewriteValueAMD64_OpIsNonNil(v) case OpIsSliceInBounds: - return rewriteValueAMD64_OpIsSliceInBounds(v, config) + return rewriteValueAMD64_OpIsSliceInBounds(v) case OpLeq16: - return rewriteValueAMD64_OpLeq16(v, config) + return rewriteValueAMD64_OpLeq16(v) case OpLeq16U: - return rewriteValueAMD64_OpLeq16U(v, config) + return rewriteValueAMD64_OpLeq16U(v) case OpLeq32: - return rewriteValueAMD64_OpLeq32(v, config) + return rewriteValueAMD64_OpLeq32(v) case OpLeq32F: - return rewriteValueAMD64_OpLeq32F(v, config) + return rewriteValueAMD64_OpLeq32F(v) case OpLeq32U: - return rewriteValueAMD64_OpLeq32U(v, config) + return rewriteValueAMD64_OpLeq32U(v) case OpLeq64: - return rewriteValueAMD64_OpLeq64(v, config) + return rewriteValueAMD64_OpLeq64(v) case OpLeq64F: - return rewriteValueAMD64_OpLeq64F(v, config) + return rewriteValueAMD64_OpLeq64F(v) case OpLeq64U: - return rewriteValueAMD64_OpLeq64U(v, config) + return rewriteValueAMD64_OpLeq64U(v) case OpLeq8: - return rewriteValueAMD64_OpLeq8(v, config) + return rewriteValueAMD64_OpLeq8(v) case OpLeq8U: - return rewriteValueAMD64_OpLeq8U(v, config) + return rewriteValueAMD64_OpLeq8U(v) case OpLess16: - return rewriteValueAMD64_OpLess16(v, config) + return rewriteValueAMD64_OpLess16(v) case OpLess16U: - return rewriteValueAMD64_OpLess16U(v, config) + return rewriteValueAMD64_OpLess16U(v) case OpLess32: - return rewriteValueAMD64_OpLess32(v, config) + return rewriteValueAMD64_OpLess32(v) case OpLess32F: - return rewriteValueAMD64_OpLess32F(v, config) + return rewriteValueAMD64_OpLess32F(v) case OpLess32U: - return rewriteValueAMD64_OpLess32U(v, config) + return rewriteValueAMD64_OpLess32U(v) case OpLess64: - return rewriteValueAMD64_OpLess64(v, config) + return rewriteValueAMD64_OpLess64(v) case OpLess64F: - return rewriteValueAMD64_OpLess64F(v, config) + return rewriteValueAMD64_OpLess64F(v) case OpLess64U: - return rewriteValueAMD64_OpLess64U(v, config) + return rewriteValueAMD64_OpLess64U(v) case OpLess8: - return rewriteValueAMD64_OpLess8(v, config) + return rewriteValueAMD64_OpLess8(v) case OpLess8U: - return rewriteValueAMD64_OpLess8U(v, config) + return rewriteValueAMD64_OpLess8U(v) case OpLoad: - return rewriteValueAMD64_OpLoad(v, config) + return rewriteValueAMD64_OpLoad(v) case OpLsh16x16: - return rewriteValueAMD64_OpLsh16x16(v, config) + return rewriteValueAMD64_OpLsh16x16(v) case OpLsh16x32: - return rewriteValueAMD64_OpLsh16x32(v, config) + return rewriteValueAMD64_OpLsh16x32(v) case OpLsh16x64: - return rewriteValueAMD64_OpLsh16x64(v, config) + return rewriteValueAMD64_OpLsh16x64(v) case OpLsh16x8: - return rewriteValueAMD64_OpLsh16x8(v, config) + return rewriteValueAMD64_OpLsh16x8(v) case OpLsh32x16: - return rewriteValueAMD64_OpLsh32x16(v, config) + return rewriteValueAMD64_OpLsh32x16(v) case OpLsh32x32: - return rewriteValueAMD64_OpLsh32x32(v, config) + return rewriteValueAMD64_OpLsh32x32(v) case OpLsh32x64: - return rewriteValueAMD64_OpLsh32x64(v, config) + return rewriteValueAMD64_OpLsh32x64(v) case OpLsh32x8: - return rewriteValueAMD64_OpLsh32x8(v, config) + return rewriteValueAMD64_OpLsh32x8(v) case OpLsh64x16: - return rewriteValueAMD64_OpLsh64x16(v, config) + return rewriteValueAMD64_OpLsh64x16(v) case OpLsh64x32: - return rewriteValueAMD64_OpLsh64x32(v, config) + return rewriteValueAMD64_OpLsh64x32(v) case OpLsh64x64: - return rewriteValueAMD64_OpLsh64x64(v, config) + return rewriteValueAMD64_OpLsh64x64(v) case OpLsh64x8: - return rewriteValueAMD64_OpLsh64x8(v, config) + return rewriteValueAMD64_OpLsh64x8(v) case OpLsh8x16: - return rewriteValueAMD64_OpLsh8x16(v, config) + return rewriteValueAMD64_OpLsh8x16(v) case OpLsh8x32: - return rewriteValueAMD64_OpLsh8x32(v, config) + return rewriteValueAMD64_OpLsh8x32(v) case OpLsh8x64: - return rewriteValueAMD64_OpLsh8x64(v, config) + return rewriteValueAMD64_OpLsh8x64(v) case OpLsh8x8: - return rewriteValueAMD64_OpLsh8x8(v, config) + return rewriteValueAMD64_OpLsh8x8(v) case OpMod16: - return rewriteValueAMD64_OpMod16(v, config) + return rewriteValueAMD64_OpMod16(v) case OpMod16u: - return rewriteValueAMD64_OpMod16u(v, config) + return rewriteValueAMD64_OpMod16u(v) case OpMod32: - return rewriteValueAMD64_OpMod32(v, config) + return rewriteValueAMD64_OpMod32(v) case OpMod32u: - return rewriteValueAMD64_OpMod32u(v, config) + return rewriteValueAMD64_OpMod32u(v) case OpMod64: - return rewriteValueAMD64_OpMod64(v, config) + return rewriteValueAMD64_OpMod64(v) case OpMod64u: - return rewriteValueAMD64_OpMod64u(v, config) + return rewriteValueAMD64_OpMod64u(v) case OpMod8: - return rewriteValueAMD64_OpMod8(v, config) + return rewriteValueAMD64_OpMod8(v) case OpMod8u: - return rewriteValueAMD64_OpMod8u(v, config) + return rewriteValueAMD64_OpMod8u(v) case OpMove: - return rewriteValueAMD64_OpMove(v, config) + return rewriteValueAMD64_OpMove(v) case OpMul16: - return rewriteValueAMD64_OpMul16(v, config) + return rewriteValueAMD64_OpMul16(v) case OpMul32: - return rewriteValueAMD64_OpMul32(v, config) + return rewriteValueAMD64_OpMul32(v) case OpMul32F: - return rewriteValueAMD64_OpMul32F(v, config) + return rewriteValueAMD64_OpMul32F(v) case OpMul64: - return rewriteValueAMD64_OpMul64(v, config) + return rewriteValueAMD64_OpMul64(v) case OpMul64F: - return rewriteValueAMD64_OpMul64F(v, config) + return rewriteValueAMD64_OpMul64F(v) case OpMul64uhilo: - return rewriteValueAMD64_OpMul64uhilo(v, config) + return rewriteValueAMD64_OpMul64uhilo(v) case OpMul8: - return rewriteValueAMD64_OpMul8(v, config) + return rewriteValueAMD64_OpMul8(v) case OpNeg16: - return rewriteValueAMD64_OpNeg16(v, config) + return rewriteValueAMD64_OpNeg16(v) case OpNeg32: - return rewriteValueAMD64_OpNeg32(v, config) + return rewriteValueAMD64_OpNeg32(v) case OpNeg32F: - return rewriteValueAMD64_OpNeg32F(v, config) + return rewriteValueAMD64_OpNeg32F(v) case OpNeg64: - return rewriteValueAMD64_OpNeg64(v, config) + return rewriteValueAMD64_OpNeg64(v) case OpNeg64F: - return rewriteValueAMD64_OpNeg64F(v, config) + return rewriteValueAMD64_OpNeg64F(v) case OpNeg8: - return rewriteValueAMD64_OpNeg8(v, config) + return rewriteValueAMD64_OpNeg8(v) case OpNeq16: - return rewriteValueAMD64_OpNeq16(v, config) + return rewriteValueAMD64_OpNeq16(v) case OpNeq32: - return rewriteValueAMD64_OpNeq32(v, config) + return rewriteValueAMD64_OpNeq32(v) case OpNeq32F: - return rewriteValueAMD64_OpNeq32F(v, config) + return rewriteValueAMD64_OpNeq32F(v) case OpNeq64: - return rewriteValueAMD64_OpNeq64(v, config) + return rewriteValueAMD64_OpNeq64(v) case OpNeq64F: - return rewriteValueAMD64_OpNeq64F(v, config) + return rewriteValueAMD64_OpNeq64F(v) case OpNeq8: - return rewriteValueAMD64_OpNeq8(v, config) + return rewriteValueAMD64_OpNeq8(v) case OpNeqB: - return rewriteValueAMD64_OpNeqB(v, config) + return rewriteValueAMD64_OpNeqB(v) case OpNeqPtr: - return rewriteValueAMD64_OpNeqPtr(v, config) + return rewriteValueAMD64_OpNeqPtr(v) case OpNilCheck: - return rewriteValueAMD64_OpNilCheck(v, config) + return rewriteValueAMD64_OpNilCheck(v) case OpNot: - return rewriteValueAMD64_OpNot(v, config) + return rewriteValueAMD64_OpNot(v) case OpOffPtr: - return rewriteValueAMD64_OpOffPtr(v, config) + return rewriteValueAMD64_OpOffPtr(v) case OpOr16: - return rewriteValueAMD64_OpOr16(v, config) + return rewriteValueAMD64_OpOr16(v) case OpOr32: - return rewriteValueAMD64_OpOr32(v, config) + return rewriteValueAMD64_OpOr32(v) case OpOr64: - return rewriteValueAMD64_OpOr64(v, config) + return rewriteValueAMD64_OpOr64(v) case OpOr8: - return rewriteValueAMD64_OpOr8(v, config) + return rewriteValueAMD64_OpOr8(v) case OpOrB: - return rewriteValueAMD64_OpOrB(v, config) + return rewriteValueAMD64_OpOrB(v) case OpRound32F: - return rewriteValueAMD64_OpRound32F(v, config) + return rewriteValueAMD64_OpRound32F(v) case OpRound64F: - return rewriteValueAMD64_OpRound64F(v, config) + return rewriteValueAMD64_OpRound64F(v) case OpRsh16Ux16: - return rewriteValueAMD64_OpRsh16Ux16(v, config) + return rewriteValueAMD64_OpRsh16Ux16(v) case OpRsh16Ux32: - return rewriteValueAMD64_OpRsh16Ux32(v, config) + return rewriteValueAMD64_OpRsh16Ux32(v) case OpRsh16Ux64: - return rewriteValueAMD64_OpRsh16Ux64(v, config) + return rewriteValueAMD64_OpRsh16Ux64(v) case OpRsh16Ux8: - return rewriteValueAMD64_OpRsh16Ux8(v, config) + return rewriteValueAMD64_OpRsh16Ux8(v) case OpRsh16x16: - return rewriteValueAMD64_OpRsh16x16(v, config) + return rewriteValueAMD64_OpRsh16x16(v) case OpRsh16x32: - return rewriteValueAMD64_OpRsh16x32(v, config) + return rewriteValueAMD64_OpRsh16x32(v) case OpRsh16x64: - return rewriteValueAMD64_OpRsh16x64(v, config) + return rewriteValueAMD64_OpRsh16x64(v) case OpRsh16x8: - return rewriteValueAMD64_OpRsh16x8(v, config) + return rewriteValueAMD64_OpRsh16x8(v) case OpRsh32Ux16: - return rewriteValueAMD64_OpRsh32Ux16(v, config) + return rewriteValueAMD64_OpRsh32Ux16(v) case OpRsh32Ux32: - return rewriteValueAMD64_OpRsh32Ux32(v, config) + return rewriteValueAMD64_OpRsh32Ux32(v) case OpRsh32Ux64: - return rewriteValueAMD64_OpRsh32Ux64(v, config) + return rewriteValueAMD64_OpRsh32Ux64(v) case OpRsh32Ux8: - return rewriteValueAMD64_OpRsh32Ux8(v, config) + return rewriteValueAMD64_OpRsh32Ux8(v) case OpRsh32x16: - return rewriteValueAMD64_OpRsh32x16(v, config) + return rewriteValueAMD64_OpRsh32x16(v) case OpRsh32x32: - return rewriteValueAMD64_OpRsh32x32(v, config) + return rewriteValueAMD64_OpRsh32x32(v) case OpRsh32x64: - return rewriteValueAMD64_OpRsh32x64(v, config) + return rewriteValueAMD64_OpRsh32x64(v) case OpRsh32x8: - return rewriteValueAMD64_OpRsh32x8(v, config) + return rewriteValueAMD64_OpRsh32x8(v) case OpRsh64Ux16: - return rewriteValueAMD64_OpRsh64Ux16(v, config) + return rewriteValueAMD64_OpRsh64Ux16(v) case OpRsh64Ux32: - return rewriteValueAMD64_OpRsh64Ux32(v, config) + return rewriteValueAMD64_OpRsh64Ux32(v) case OpRsh64Ux64: - return rewriteValueAMD64_OpRsh64Ux64(v, config) + return rewriteValueAMD64_OpRsh64Ux64(v) case OpRsh64Ux8: - return rewriteValueAMD64_OpRsh64Ux8(v, config) + return rewriteValueAMD64_OpRsh64Ux8(v) case OpRsh64x16: - return rewriteValueAMD64_OpRsh64x16(v, config) + return rewriteValueAMD64_OpRsh64x16(v) case OpRsh64x32: - return rewriteValueAMD64_OpRsh64x32(v, config) + return rewriteValueAMD64_OpRsh64x32(v) case OpRsh64x64: - return rewriteValueAMD64_OpRsh64x64(v, config) + return rewriteValueAMD64_OpRsh64x64(v) case OpRsh64x8: - return rewriteValueAMD64_OpRsh64x8(v, config) + return rewriteValueAMD64_OpRsh64x8(v) case OpRsh8Ux16: - return rewriteValueAMD64_OpRsh8Ux16(v, config) + return rewriteValueAMD64_OpRsh8Ux16(v) case OpRsh8Ux32: - return rewriteValueAMD64_OpRsh8Ux32(v, config) + return rewriteValueAMD64_OpRsh8Ux32(v) case OpRsh8Ux64: - return rewriteValueAMD64_OpRsh8Ux64(v, config) + return rewriteValueAMD64_OpRsh8Ux64(v) case OpRsh8Ux8: - return rewriteValueAMD64_OpRsh8Ux8(v, config) + return rewriteValueAMD64_OpRsh8Ux8(v) case OpRsh8x16: - return rewriteValueAMD64_OpRsh8x16(v, config) + return rewriteValueAMD64_OpRsh8x16(v) case OpRsh8x32: - return rewriteValueAMD64_OpRsh8x32(v, config) + return rewriteValueAMD64_OpRsh8x32(v) case OpRsh8x64: - return rewriteValueAMD64_OpRsh8x64(v, config) + return rewriteValueAMD64_OpRsh8x64(v) case OpRsh8x8: - return rewriteValueAMD64_OpRsh8x8(v, config) + return rewriteValueAMD64_OpRsh8x8(v) case OpSelect0: - return rewriteValueAMD64_OpSelect0(v, config) + return rewriteValueAMD64_OpSelect0(v) case OpSelect1: - return rewriteValueAMD64_OpSelect1(v, config) + return rewriteValueAMD64_OpSelect1(v) case OpSignExt16to32: - return rewriteValueAMD64_OpSignExt16to32(v, config) + return rewriteValueAMD64_OpSignExt16to32(v) case OpSignExt16to64: - return rewriteValueAMD64_OpSignExt16to64(v, config) + return rewriteValueAMD64_OpSignExt16to64(v) case OpSignExt32to64: - return rewriteValueAMD64_OpSignExt32to64(v, config) + return rewriteValueAMD64_OpSignExt32to64(v) case OpSignExt8to16: - return rewriteValueAMD64_OpSignExt8to16(v, config) + return rewriteValueAMD64_OpSignExt8to16(v) case OpSignExt8to32: - return rewriteValueAMD64_OpSignExt8to32(v, config) + return rewriteValueAMD64_OpSignExt8to32(v) case OpSignExt8to64: - return rewriteValueAMD64_OpSignExt8to64(v, config) + return rewriteValueAMD64_OpSignExt8to64(v) case OpSlicemask: - return rewriteValueAMD64_OpSlicemask(v, config) + return rewriteValueAMD64_OpSlicemask(v) case OpSqrt: - return rewriteValueAMD64_OpSqrt(v, config) + return rewriteValueAMD64_OpSqrt(v) case OpStaticCall: - return rewriteValueAMD64_OpStaticCall(v, config) + return rewriteValueAMD64_OpStaticCall(v) case OpStore: - return rewriteValueAMD64_OpStore(v, config) + return rewriteValueAMD64_OpStore(v) case OpSub16: - return rewriteValueAMD64_OpSub16(v, config) + return rewriteValueAMD64_OpSub16(v) case OpSub32: - return rewriteValueAMD64_OpSub32(v, config) + return rewriteValueAMD64_OpSub32(v) case OpSub32F: - return rewriteValueAMD64_OpSub32F(v, config) + return rewriteValueAMD64_OpSub32F(v) case OpSub64: - return rewriteValueAMD64_OpSub64(v, config) + return rewriteValueAMD64_OpSub64(v) case OpSub64F: - return rewriteValueAMD64_OpSub64F(v, config) + return rewriteValueAMD64_OpSub64F(v) case OpSub8: - return rewriteValueAMD64_OpSub8(v, config) + return rewriteValueAMD64_OpSub8(v) case OpSubPtr: - return rewriteValueAMD64_OpSubPtr(v, config) + return rewriteValueAMD64_OpSubPtr(v) case OpTrunc16to8: - return rewriteValueAMD64_OpTrunc16to8(v, config) + return rewriteValueAMD64_OpTrunc16to8(v) case OpTrunc32to16: - return rewriteValueAMD64_OpTrunc32to16(v, config) + return rewriteValueAMD64_OpTrunc32to16(v) case OpTrunc32to8: - return rewriteValueAMD64_OpTrunc32to8(v, config) + return rewriteValueAMD64_OpTrunc32to8(v) case OpTrunc64to16: - return rewriteValueAMD64_OpTrunc64to16(v, config) + return rewriteValueAMD64_OpTrunc64to16(v) case OpTrunc64to32: - return rewriteValueAMD64_OpTrunc64to32(v, config) + return rewriteValueAMD64_OpTrunc64to32(v) case OpTrunc64to8: - return rewriteValueAMD64_OpTrunc64to8(v, config) + return rewriteValueAMD64_OpTrunc64to8(v) case OpXor16: - return rewriteValueAMD64_OpXor16(v, config) + return rewriteValueAMD64_OpXor16(v) case OpXor32: - return rewriteValueAMD64_OpXor32(v, config) + return rewriteValueAMD64_OpXor32(v) case OpXor64: - return rewriteValueAMD64_OpXor64(v, config) + return rewriteValueAMD64_OpXor64(v) case OpXor8: - return rewriteValueAMD64_OpXor8(v, config) + return rewriteValueAMD64_OpXor8(v) case OpZero: - return rewriteValueAMD64_OpZero(v, config) + return rewriteValueAMD64_OpZero(v) case OpZeroExt16to32: - return rewriteValueAMD64_OpZeroExt16to32(v, config) + return rewriteValueAMD64_OpZeroExt16to32(v) case OpZeroExt16to64: - return rewriteValueAMD64_OpZeroExt16to64(v, config) + return rewriteValueAMD64_OpZeroExt16to64(v) case OpZeroExt32to64: - return rewriteValueAMD64_OpZeroExt32to64(v, config) + return rewriteValueAMD64_OpZeroExt32to64(v) case OpZeroExt8to16: - return rewriteValueAMD64_OpZeroExt8to16(v, config) + return rewriteValueAMD64_OpZeroExt8to16(v) case OpZeroExt8to32: - return rewriteValueAMD64_OpZeroExt8to32(v, config) + return rewriteValueAMD64_OpZeroExt8to32(v) case OpZeroExt8to64: - return rewriteValueAMD64_OpZeroExt8to64(v, config) + return rewriteValueAMD64_OpZeroExt8to64(v) } return false } -func rewriteValueAMD64_OpAMD64ADDL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ADDL(v *Value) bool { // match: (ADDL x (MOVLconst [c])) // cond: // result: (ADDLconst [c] x) @@ -1091,9 +1089,7 @@ func rewriteValueAMD64_OpAMD64ADDL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ADDLconst(v *Value) bool { // match: (ADDLconst [c] x) // cond: int32(c)==0 // result: x @@ -1161,9 +1157,7 @@ func rewriteValueAMD64_OpAMD64ADDLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool { // match: (ADDQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (ADDQconst [c] x) @@ -1501,9 +1495,7 @@ func rewriteValueAMD64_OpAMD64ADDQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ADDQconst(v *Value) bool { // match: (ADDQconst [c] (ADDQ x y)) // cond: // result: (LEAQ1 [c] x y) @@ -1682,9 +1674,7 @@ func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDSD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ADDSD(v *Value) bool { // match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem)) // cond: l.Uses == 1 && canMergeLoad(v, l) && clobber(l) // result: (ADDSDmem x [off] {sym} ptr mem) @@ -1735,9 +1725,7 @@ func rewriteValueAMD64_OpAMD64ADDSD(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDSS(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ADDSS(v *Value) bool { // match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem)) // cond: l.Uses == 1 && canMergeLoad(v, l) && clobber(l) // result: (ADDSSmem x [off] {sym} ptr mem) @@ -1788,9 +1776,7 @@ func rewriteValueAMD64_OpAMD64ADDSS(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ANDL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ANDL(v *Value) bool { // match: (ANDL x (MOVLconst [c])) // cond: // result: (ANDLconst [c] x) @@ -1884,9 +1870,7 @@ func rewriteValueAMD64_OpAMD64ANDL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ANDLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ANDLconst(v *Value) bool { // match: (ANDLconst [c] (ANDLconst [d] x)) // cond: // result: (ANDLconst [c & d] x) @@ -1969,9 +1953,7 @@ func rewriteValueAMD64_OpAMD64ANDLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ANDQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ANDQ(v *Value) bool { // match: (ANDQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (ANDQconst [c] x) @@ -2071,9 +2053,7 @@ func rewriteValueAMD64_OpAMD64ANDQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ANDQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ANDQconst(v *Value) bool { // match: (ANDQconst [c] (ANDQconst [d] x)) // cond: // result: (ANDQconst [c & d] x) @@ -2166,7 +2146,7 @@ func rewriteValueAMD64_OpAMD64ANDQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64BSFQ(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64BSFQ(v *Value) bool { b := v.Block _ = b // match: (BSFQ (ORQconst <t> [1<<8] (MOVBQZX x))) @@ -2219,9 +2199,7 @@ func rewriteValueAMD64_OpAMD64BSFQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64BTQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64BTQconst(v *Value) bool { // match: (BTQconst [c] x) // cond: c < 32 // result: (BTLconst [c] x) @@ -2238,9 +2216,7 @@ func rewriteValueAMD64_OpAMD64BTQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value) bool { // match: (CMOVQEQ x _ (Select1 (BSFQ (ORQconst [c] _)))) // cond: c != 0 // result: x @@ -2269,7 +2245,7 @@ func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPB(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool { b := v.Block _ = b // match: (CMPB x (MOVLconst [c])) @@ -2306,9 +2282,7 @@ func rewriteValueAMD64_OpAMD64CMPB(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool { // match: (CMPBconst (MOVLconst [x]) [y]) // cond: int8(x)==int8(y) // result: (FlagEQ) @@ -2456,7 +2430,7 @@ func rewriteValueAMD64_OpAMD64CMPBconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool { b := v.Block _ = b // match: (CMPL x (MOVLconst [c])) @@ -2493,9 +2467,7 @@ func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool { // match: (CMPLconst (MOVLconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -2659,7 +2631,7 @@ func rewriteValueAMD64_OpAMD64CMPLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPQ(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool { b := v.Block _ = b // match: (CMPQ x (MOVQconst [c])) @@ -2702,9 +2674,7 @@ func rewriteValueAMD64_OpAMD64CMPQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool { // match: (CMPQconst (MOVQconst [x]) [y]) // cond: x==y // result: (FlagEQ) @@ -2913,7 +2883,7 @@ func rewriteValueAMD64_OpAMD64CMPQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64CMPW(v *Value) bool { b := v.Block _ = b // match: (CMPW x (MOVLconst [c])) @@ -2950,9 +2920,7 @@ func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool { // match: (CMPWconst (MOVLconst [x]) [y]) // cond: int16(x)==int16(y) // result: (FlagEQ) @@ -3100,9 +3068,7 @@ func rewriteValueAMD64_OpAMD64CMPWconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPXCHGLlock(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64CMPXCHGLlock(v *Value) bool { // match: (CMPXCHGLlock [off1] {sym} (ADDQconst [off2] ptr) old new_ mem) // cond: is32Bit(off1+off2) // result: (CMPXCHGLlock [off1+off2] {sym} ptr old new_ mem) @@ -3132,9 +3098,7 @@ func rewriteValueAMD64_OpAMD64CMPXCHGLlock(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPXCHGQlock(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64CMPXCHGQlock(v *Value) bool { // match: (CMPXCHGQlock [off1] {sym} (ADDQconst [off2] ptr) old new_ mem) // cond: is32Bit(off1+off2) // result: (CMPXCHGQlock [off1+off2] {sym} ptr old new_ mem) @@ -3164,9 +3128,7 @@ func rewriteValueAMD64_OpAMD64CMPXCHGQlock(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64LEAL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64LEAL(v *Value) bool { // match: (LEAL [c] {s} (ADDLconst [d] x)) // cond: is32Bit(c+d) // result: (LEAL [c+d] {s} x) @@ -3190,9 +3152,7 @@ func rewriteValueAMD64_OpAMD64LEAL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64LEAQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64LEAQ(v *Value) bool { // match: (LEAQ [c] {s} (ADDQconst [d] x)) // cond: is32Bit(c+d) // result: (LEAQ [c+d] {s} x) @@ -3356,9 +3316,7 @@ func rewriteValueAMD64_OpAMD64LEAQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64LEAQ1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64LEAQ1(v *Value) bool { // match: (LEAQ1 [c] {s} (ADDQconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAQ1 [c+d] {s} x y) @@ -3587,9 +3545,7 @@ func rewriteValueAMD64_OpAMD64LEAQ1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64LEAQ2(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64LEAQ2(v *Value) bool { // match: (LEAQ2 [c] {s} (ADDQconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAQ2 [c+d] {s} x y) @@ -3706,9 +3662,7 @@ func rewriteValueAMD64_OpAMD64LEAQ2(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64LEAQ4(v *Value) bool { // match: (LEAQ4 [c] {s} (ADDQconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAQ4 [c+d] {s} x y) @@ -3803,9 +3757,7 @@ func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64LEAQ8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64LEAQ8(v *Value) bool { // match: (LEAQ8 [c] {s} (ADDQconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAQ8 [c+d] {s} x y) @@ -3878,7 +3830,7 @@ func rewriteValueAMD64_OpAMD64LEAQ8(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value) bool { b := v.Block _ = b // match: (MOVBQSX x:(MOVBload [off] {sym} ptr mem)) @@ -4014,9 +3966,7 @@ func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVBQSXload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVBQSXload(v *Value) bool { // match: (MOVBQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) // result: (MOVBQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem) @@ -4043,7 +3993,7 @@ func rewriteValueAMD64_OpAMD64MOVBQSXload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value) bool { b := v.Block _ = b // match: (MOVBQZX x:(MOVBload [off] {sym} ptr mem)) @@ -4203,9 +4153,7 @@ func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVBload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVBload(v *Value) bool { // match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: x @@ -4375,9 +4323,7 @@ func rewriteValueAMD64_OpAMD64MOVBload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value) bool { // match: (MOVBloadidx1 [c] {sym} (ADDQconst [d] ptr) idx mem) // cond: // result: (MOVBloadidx1 [c+d] {sym} ptr idx mem) @@ -4424,7 +4370,7 @@ func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVBstore(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool { b := v.Block _ = b // match: (MOVBstore [off] {sym} ptr (MOVBQSX x) mem) @@ -5061,9 +5007,7 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool { // match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -5236,9 +5180,7 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v *Value) bool { // match: (MOVBstoreconstidx1 [x] {sym} (ADDQconst [c] ptr) idx mem) // cond: // result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem) @@ -5319,7 +5261,7 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v *Value, config *Config) bool } return false } -func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value) bool { b := v.Block _ = b // match: (MOVBstoreidx1 [c] {sym} (ADDQconst [d] ptr) idx val mem) @@ -5832,7 +5774,7 @@ func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value) bool { b := v.Block _ = b // match: (MOVLQSX x:(MOVLload [off] {sym} ptr mem)) @@ -5944,9 +5886,7 @@ func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLQSXload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVLQSXload(v *Value) bool { // match: (MOVLQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) // result: (MOVLQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem) @@ -5973,7 +5913,7 @@ func rewriteValueAMD64_OpAMD64MOVLQSXload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value) bool { b := v.Block _ = b // match: (MOVLQZX x:(MOVLload [off] {sym} ptr mem)) @@ -6136,9 +6076,7 @@ func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLatomicload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVLatomicload(v *Value) bool { // match: (MOVLatomicload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVLatomicload [off1+off2] {sym} ptr mem) @@ -6188,9 +6126,7 @@ func rewriteValueAMD64_OpAMD64MOVLatomicload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVLload(v *Value) bool { // match: (MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: x @@ -6386,9 +6322,7 @@ func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVLloadidx1(v *Value) bool { // match: (MOVLloadidx1 [c] {sym} ptr (SHLQconst [2] idx) mem) // cond: // result: (MOVLloadidx4 [c] {sym} ptr idx mem) @@ -6459,9 +6393,7 @@ func rewriteValueAMD64_OpAMD64MOVLloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value) bool { // match: (MOVLloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem) // cond: // result: (MOVLloadidx4 [c+d] {sym} ptr idx mem) @@ -6508,9 +6440,7 @@ func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool { // match: (MOVLstore [off] {sym} ptr (MOVLQSX x) mem) // cond: // result: (MOVLstore [off] {sym} ptr x mem) @@ -6853,9 +6783,13 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -7002,7 +6936,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { v.AuxInt = ValAndOff(a).Off() v.Aux = s v.AddArg(p) - v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32 v.AddArg(v0) v.AddArg(mem) @@ -7057,9 +6991,13 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLQconst [2] idx) mem) // cond: // result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem) @@ -7159,7 +7097,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value, config *Config) bool v.Aux = s v.AddArg(p) v.AddArg(i) - v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32 v.AddArg(v0) v.AddArg(mem) @@ -7167,9 +7105,13 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value, config *Config) bool } return false } -func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (MOVLstoreconstidx4 [x] {sym} (ADDQconst [c] ptr) idx mem) // cond: // result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem) @@ -7248,7 +7190,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value, config *Config) bool v0.AuxInt = 2 v0.AddArg(i) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v1.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32 v.AddArg(v1) v.AddArg(mem) @@ -7256,9 +7198,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value, config *Config) bool } return false } -func rewriteValueAMD64_OpAMD64MOVLstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVLstoreidx1(v *Value) bool { // match: (MOVLstoreidx1 [c] {sym} ptr (SHLQconst [2] idx) val mem) // cond: // result: (MOVLstoreidx4 [c] {sym} ptr idx val mem) @@ -7436,7 +7376,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value) bool { b := v.Block _ = b // match: (MOVLstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem) @@ -7596,9 +7536,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVOload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVOload(v *Value) bool { // match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVOload [off1+off2] {sym} ptr mem) @@ -7648,9 +7586,7 @@ func rewriteValueAMD64_OpAMD64MOVOload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVOstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVOstore(v *Value) bool { // match: (MOVOstore [off1] {sym} (ADDQconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVOstore [off1+off2] {sym} ptr val mem) @@ -7704,9 +7640,7 @@ func rewriteValueAMD64_OpAMD64MOVOstore(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVQatomicload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQatomicload(v *Value) bool { // match: (MOVQatomicload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVQatomicload [off1+off2] {sym} ptr mem) @@ -7756,9 +7690,7 @@ func rewriteValueAMD64_OpAMD64MOVQatomicload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVQload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQload(v *Value) bool { // match: (MOVQload [off] {sym} ptr (MOVQstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: x @@ -7954,9 +7886,7 @@ func rewriteValueAMD64_OpAMD64MOVQload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVQloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQloadidx1(v *Value) bool { // match: (MOVQloadidx1 [c] {sym} ptr (SHLQconst [3] idx) mem) // cond: // result: (MOVQloadidx8 [c] {sym} ptr idx mem) @@ -8027,9 +7957,7 @@ func rewriteValueAMD64_OpAMD64MOVQloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value) bool { // match: (MOVQloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem) // cond: // result: (MOVQloadidx8 [c+d] {sym} ptr idx mem) @@ -8076,9 +8004,7 @@ func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVQstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool { // match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVQstore [off1+off2] {sym} ptr val mem) @@ -8288,9 +8214,7 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool { // match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVQstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -8460,9 +8384,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v *Value) bool { // match: (MOVQstoreconstidx1 [c] {sym} ptr (SHLQconst [3] idx) mem) // cond: // result: (MOVQstoreconstidx8 [c] {sym} ptr idx mem) @@ -8533,9 +8455,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v *Value, config *Config) bool } return false } -func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v *Value) bool { // match: (MOVQstoreconstidx8 [x] {sym} (ADDQconst [c] ptr) idx mem) // cond: // result: (MOVQstoreconstidx8 [ValAndOff(x).add(c)] {sym} ptr idx mem) @@ -8582,9 +8502,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v *Value, config *Config) bool } return false } -func rewriteValueAMD64_OpAMD64MOVQstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQstoreidx1(v *Value) bool { // match: (MOVQstoreidx1 [c] {sym} ptr (SHLQconst [3] idx) val mem) // cond: // result: (MOVQstoreidx8 [c] {sym} ptr idx val mem) @@ -8661,9 +8579,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value) bool { // match: (MOVQstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem) // cond: // result: (MOVQstoreidx8 [c+d] {sym} ptr idx val mem) @@ -8714,9 +8630,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSDload(v *Value) bool { // match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVSDload [off1+off2] {sym} ptr mem) @@ -8842,9 +8756,7 @@ func rewriteValueAMD64_OpAMD64MOVSDload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSDloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSDloadidx1(v *Value) bool { // match: (MOVSDloadidx1 [c] {sym} ptr (SHLQconst [3] idx) mem) // cond: // result: (MOVSDloadidx8 [c] {sym} ptr idx mem) @@ -8915,9 +8827,7 @@ func rewriteValueAMD64_OpAMD64MOVSDloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value) bool { // match: (MOVSDloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem) // cond: // result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem) @@ -8964,9 +8874,7 @@ func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value) bool { // match: (MOVSDstore [off1] {sym} (ADDQconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVSDstore [off1+off2] {sym} ptr val mem) @@ -9102,9 +9010,7 @@ func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v *Value) bool { // match: (MOVSDstoreidx1 [c] {sym} ptr (SHLQconst [3] idx) val mem) // cond: // result: (MOVSDstoreidx8 [c] {sym} ptr idx val mem) @@ -9181,9 +9087,7 @@ func rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value) bool { // match: (MOVSDstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem) // cond: // result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem) @@ -9234,9 +9138,7 @@ func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSSload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSSload(v *Value) bool { // match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVSSload [off1+off2] {sym} ptr mem) @@ -9362,9 +9264,7 @@ func rewriteValueAMD64_OpAMD64MOVSSload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSSloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSSloadidx1(v *Value) bool { // match: (MOVSSloadidx1 [c] {sym} ptr (SHLQconst [2] idx) mem) // cond: // result: (MOVSSloadidx4 [c] {sym} ptr idx mem) @@ -9435,9 +9335,7 @@ func rewriteValueAMD64_OpAMD64MOVSSloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value) bool { // match: (MOVSSloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem) // cond: // result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem) @@ -9484,9 +9382,7 @@ func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value) bool { // match: (MOVSSstore [off1] {sym} (ADDQconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVSSstore [off1+off2] {sym} ptr val mem) @@ -9622,9 +9518,7 @@ func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v *Value) bool { // match: (MOVSSstoreidx1 [c] {sym} ptr (SHLQconst [2] idx) val mem) // cond: // result: (MOVSSstoreidx4 [c] {sym} ptr idx val mem) @@ -9701,9 +9595,7 @@ func rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value) bool { // match: (MOVSSstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem) // cond: // result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem) @@ -9754,7 +9646,7 @@ func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value) bool { b := v.Block _ = b // match: (MOVWQSX x:(MOVWload [off] {sym} ptr mem)) @@ -9878,9 +9770,7 @@ func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWQSXload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVWQSXload(v *Value) bool { // match: (MOVWQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) // result: (MOVWQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem) @@ -9907,7 +9797,7 @@ func rewriteValueAMD64_OpAMD64MOVWQSXload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value) bool { b := v.Block _ = b // match: (MOVWQZX x:(MOVWload [off] {sym} ptr mem)) @@ -10082,9 +9972,7 @@ func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVWload(v *Value) bool { // match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: x @@ -10280,9 +10168,7 @@ func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWloadidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVWloadidx1(v *Value) bool { // match: (MOVWloadidx1 [c] {sym} ptr (SHLQconst [1] idx) mem) // cond: // result: (MOVWloadidx2 [c] {sym} ptr idx mem) @@ -10353,9 +10239,7 @@ func rewriteValueAMD64_OpAMD64MOVWloadidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value) bool { // match: (MOVWloadidx2 [c] {sym} (ADDQconst [d] ptr) idx mem) // cond: // result: (MOVWloadidx2 [c+d] {sym} ptr idx mem) @@ -10402,9 +10286,7 @@ func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool { // match: (MOVWstore [off] {sym} ptr (MOVWQSX x) mem) // cond: // result: (MOVWstore [off] {sym} ptr x mem) @@ -10747,9 +10629,7 @@ func rewriteValueAMD64_OpAMD64MOVWstore(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool { // match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -10948,9 +10828,7 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v *Value) bool { // match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLQconst [1] idx) mem) // cond: // result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem) @@ -11055,7 +10933,7 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v *Value, config *Config) bool } return false } -func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v *Value) bool { b := v.Block _ = b // match: (MOVWstoreconstidx2 [x] {sym} (ADDQconst [c] ptr) idx mem) @@ -11141,9 +11019,7 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v *Value, config *Config) bool } return false } -func rewriteValueAMD64_OpAMD64MOVWstoreidx1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MOVWstoreidx1(v *Value) bool { // match: (MOVWstoreidx1 [c] {sym} ptr (SHLQconst [1] idx) val mem) // cond: // result: (MOVWstoreidx2 [c] {sym} ptr idx val mem) @@ -11321,7 +11197,7 @@ func rewriteValueAMD64_OpAMD64MOVWstoreidx1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value) bool { b := v.Block _ = b // match: (MOVWstoreidx2 [c] {sym} (ADDQconst [d] ptr) idx val mem) @@ -11481,9 +11357,7 @@ func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MULL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MULL(v *Value) bool { // match: (MULL x (MOVLconst [c])) // cond: // result: (MULLconst [c] x) @@ -11516,9 +11390,7 @@ func rewriteValueAMD64_OpAMD64MULL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MULLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MULLconst(v *Value) bool { // match: (MULLconst [c] (MULLconst [d] x)) // cond: // result: (MULLconst [int64(int32(c * d))] x) @@ -11551,9 +11423,7 @@ func rewriteValueAMD64_OpAMD64MULLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MULQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MULQ(v *Value) bool { // match: (MULQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (MULQconst [c] x) @@ -11592,7 +11462,7 @@ func rewriteValueAMD64_OpAMD64MULQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MULQconst(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MULQconst(v *Value) bool { b := v.Block _ = b // match: (MULQconst [c] (MULQconst [d] x)) @@ -11982,9 +11852,7 @@ func rewriteValueAMD64_OpAMD64MULQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MULSD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MULSD(v *Value) bool { // match: (MULSD x l:(MOVSDload [off] {sym} ptr mem)) // cond: l.Uses == 1 && canMergeLoad(v, l) && clobber(l) // result: (MULSDmem x [off] {sym} ptr mem) @@ -12035,9 +11903,7 @@ func rewriteValueAMD64_OpAMD64MULSD(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64MULSS(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64MULSS(v *Value) bool { // match: (MULSS x l:(MOVSSload [off] {sym} ptr mem)) // cond: l.Uses == 1 && canMergeLoad(v, l) && clobber(l) // result: (MULSSmem x [off] {sym} ptr mem) @@ -12088,9 +11954,7 @@ func rewriteValueAMD64_OpAMD64MULSS(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64NEGL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64NEGL(v *Value) bool { // match: (NEGL (MOVLconst [c])) // cond: // result: (MOVLconst [int64(int32(-c))]) @@ -12106,9 +11970,7 @@ func rewriteValueAMD64_OpAMD64NEGL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64NEGQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64NEGQ(v *Value) bool { // match: (NEGQ (MOVQconst [c])) // cond: // result: (MOVQconst [-c]) @@ -12146,9 +12008,7 @@ func rewriteValueAMD64_OpAMD64NEGQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64NOTL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64NOTL(v *Value) bool { // match: (NOTL (MOVLconst [c])) // cond: // result: (MOVLconst [^c]) @@ -12164,9 +12024,7 @@ func rewriteValueAMD64_OpAMD64NOTL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64NOTQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64NOTQ(v *Value) bool { // match: (NOTQ (MOVQconst [c])) // cond: // result: (MOVQconst [^c]) @@ -12182,9 +12040,13 @@ func rewriteValueAMD64_OpAMD64NOTQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ORL x (MOVLconst [c])) // cond: // result: (ORLconst [c] x) @@ -12450,7 +12312,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1) - v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i @@ -12525,7 +12387,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1, x2) - v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i @@ -12713,7 +12575,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = 8 - v1 := b.NewValue0(v.Pos, OpAMD64MOVWload, config.fe.TypeUInt16()) + v1 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v1.AuxInt = i - 1 v1.Aux = s v1.AddArg(p) @@ -12853,7 +12715,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { v0 := b.NewValue0(v.Pos, OpAMD64BSWAPL, v.Type) v.reset(OpCopy) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpAMD64MOVLload, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v1.AuxInt = i1 - 2 v1.Aux = s v1.AddArg(p) @@ -13003,9 +12865,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ORLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ORLconst(v *Value) bool { // match: (ORLconst [c] x) // cond: int32(c)==0 // result: x @@ -13048,9 +12908,13 @@ func rewriteValueAMD64_OpAMD64ORLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ORQ(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ORQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (ORQconst [c] x) @@ -13368,7 +13232,7 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7) - v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i @@ -13814,7 +13678,7 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value, config *Config) bool { v0 := b.NewValue0(v.Pos, OpAMD64BSWAPQ, v.Type) v.reset(OpCopy) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpAMD64MOVQload, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v1.AuxInt = i - 7 v1.Aux = s v1.AddArg(p) @@ -14107,9 +13971,7 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ORQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ORQconst(v *Value) bool { // match: (ORQconst [0] x) // cond: // result: x @@ -14150,9 +14012,7 @@ func rewriteValueAMD64_OpAMD64ORQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ROLBconst(v *Value) bool { // match: (ROLBconst [c] (ROLBconst [d] x)) // cond: // result: (ROLBconst [(c+d)& 7] x) @@ -14184,9 +14044,7 @@ func rewriteValueAMD64_OpAMD64ROLBconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ROLLconst(v *Value) bool { // match: (ROLLconst [c] (ROLLconst [d] x)) // cond: // result: (ROLLconst [(c+d)&31] x) @@ -14218,9 +14076,7 @@ func rewriteValueAMD64_OpAMD64ROLLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ROLQconst(v *Value) bool { // match: (ROLQconst [c] (ROLQconst [d] x)) // cond: // result: (ROLQconst [(c+d)&63] x) @@ -14252,9 +14108,7 @@ func rewriteValueAMD64_OpAMD64ROLQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64ROLWconst(v *Value) bool { // match: (ROLWconst [c] (ROLWconst [d] x)) // cond: // result: (ROLWconst [(c+d)&15] x) @@ -14286,9 +14140,7 @@ func rewriteValueAMD64_OpAMD64ROLWconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SARB(v *Value) bool { // match: (SARB x (MOVQconst [c])) // cond: // result: (SARBconst [min(c&31,7)] x) @@ -14321,9 +14173,7 @@ func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SARBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SARBconst(v *Value) bool { // match: (SARBconst x [0]) // cond: // result: x @@ -14353,9 +14203,7 @@ func rewriteValueAMD64_OpAMD64SARBconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SARL(v *Value) bool { // match: (SARL x (MOVQconst [c])) // cond: // result: (SARLconst [c&31] x) @@ -14406,9 +14254,7 @@ func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SARLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SARLconst(v *Value) bool { // match: (SARLconst x [0]) // cond: // result: x @@ -14438,9 +14284,7 @@ func rewriteValueAMD64_OpAMD64SARLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SARQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SARQ(v *Value) bool { // match: (SARQ x (MOVQconst [c])) // cond: // result: (SARQconst [c&63] x) @@ -14491,9 +14335,7 @@ func rewriteValueAMD64_OpAMD64SARQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SARQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SARQconst(v *Value) bool { // match: (SARQconst x [0]) // cond: // result: x @@ -14523,9 +14365,7 @@ func rewriteValueAMD64_OpAMD64SARQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SARW(v *Value) bool { // match: (SARW x (MOVQconst [c])) // cond: // result: (SARWconst [min(c&31,15)] x) @@ -14558,9 +14398,7 @@ func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SARWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SARWconst(v *Value) bool { // match: (SARWconst x [0]) // cond: // result: x @@ -14590,9 +14428,7 @@ func rewriteValueAMD64_OpAMD64SARWconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value) bool { // match: (SBBLcarrymask (FlagEQ)) // cond: // result: (MOVLconst [0]) @@ -14655,9 +14491,7 @@ func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value) bool { // match: (SBBQcarrymask (FlagEQ)) // cond: // result: (MOVQconst [0]) @@ -14720,9 +14554,7 @@ func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SETA(v *Value) bool { // match: (SETA (InvertFlags x)) // cond: // result: (SETB x) @@ -14798,9 +14630,7 @@ func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETAE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SETAE(v *Value) bool { // match: (SETAE (InvertFlags x)) // cond: // result: (SETBE x) @@ -14876,9 +14706,7 @@ func rewriteValueAMD64_OpAMD64SETAE(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SETB(v *Value) bool { // match: (SETB (InvertFlags x)) // cond: // result: (SETA x) @@ -14954,9 +14782,7 @@ func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SETBE(v *Value) bool { // match: (SETBE (InvertFlags x)) // cond: // result: (SETAE x) @@ -15032,9 +14858,11 @@ func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64SETEQ(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (SETEQ (TESTL (SHLL (MOVLconst [1]) x) y)) // cond: !config.nacl // result: (SETAE (BTL x y)) @@ -15236,9 +15064,7 @@ func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SETG(v *Value) bool { // match: (SETG (InvertFlags x)) // cond: // result: (SETL x) @@ -15314,9 +15140,7 @@ func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SETGE(v *Value) bool { // match: (SETGE (InvertFlags x)) // cond: // result: (SETLE x) @@ -15392,9 +15216,7 @@ func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SETL(v *Value) bool { // match: (SETL (InvertFlags x)) // cond: // result: (SETG x) @@ -15470,9 +15292,7 @@ func rewriteValueAMD64_OpAMD64SETL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETLE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SETLE(v *Value) bool { // match: (SETLE (InvertFlags x)) // cond: // result: (SETGE x) @@ -15548,9 +15368,11 @@ func rewriteValueAMD64_OpAMD64SETLE(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SETNE(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64SETNE(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (SETNE (TESTL (SHLL (MOVLconst [1]) x) y)) // cond: !config.nacl // result: (SETB (BTL x y)) @@ -15752,9 +15574,7 @@ func rewriteValueAMD64_OpAMD64SETNE(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHLL(v *Value) bool { // match: (SHLL x (MOVQconst [c])) // cond: // result: (SHLLconst [c&31] x) @@ -15805,9 +15625,7 @@ func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHLLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHLLconst(v *Value) bool { // match: (SHLLconst x [0]) // cond: // result: x @@ -15823,9 +15641,7 @@ func rewriteValueAMD64_OpAMD64SHLLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHLQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHLQ(v *Value) bool { // match: (SHLQ x (MOVQconst [c])) // cond: // result: (SHLQconst [c&63] x) @@ -15876,9 +15692,7 @@ func rewriteValueAMD64_OpAMD64SHLQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHLQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHLQconst(v *Value) bool { // match: (SHLQconst x [0]) // cond: // result: x @@ -15894,9 +15708,7 @@ func rewriteValueAMD64_OpAMD64SHLQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHRB(v *Value) bool { // match: (SHRB x (MOVQconst [c])) // cond: c&31 < 8 // result: (SHRBconst [c&31] x) @@ -15967,9 +15779,7 @@ func rewriteValueAMD64_OpAMD64SHRB(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHRBconst(v *Value) bool { // match: (SHRBconst x [0]) // cond: // result: x @@ -15985,9 +15795,7 @@ func rewriteValueAMD64_OpAMD64SHRBconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHRL(v *Value) bool { // match: (SHRL x (MOVQconst [c])) // cond: // result: (SHRLconst [c&31] x) @@ -16038,9 +15846,7 @@ func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHRLconst(v *Value) bool { // match: (SHRLconst x [0]) // cond: // result: x @@ -16056,9 +15862,7 @@ func rewriteValueAMD64_OpAMD64SHRLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHRQ(v *Value) bool { // match: (SHRQ x (MOVQconst [c])) // cond: // result: (SHRQconst [c&63] x) @@ -16109,9 +15913,7 @@ func rewriteValueAMD64_OpAMD64SHRQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHRQconst(v *Value) bool { // match: (SHRQconst x [0]) // cond: // result: x @@ -16127,9 +15929,7 @@ func rewriteValueAMD64_OpAMD64SHRQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHRW(v *Value) bool { // match: (SHRW x (MOVQconst [c])) // cond: c&31 < 16 // result: (SHRWconst [c&31] x) @@ -16200,9 +16000,7 @@ func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SHRWconst(v *Value) bool { // match: (SHRWconst x [0]) // cond: // result: x @@ -16218,7 +16016,7 @@ func rewriteValueAMD64_OpAMD64SHRWconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBL(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64SUBL(v *Value) bool { b := v.Block _ = b // match: (SUBL x (MOVLconst [c])) @@ -16291,9 +16089,7 @@ func rewriteValueAMD64_OpAMD64SUBL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SUBLconst(v *Value) bool { // match: (SUBLconst [c] x) // cond: int32(c) == 0 // result: x @@ -16320,7 +16116,7 @@ func rewriteValueAMD64_OpAMD64SUBLconst(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAMD64SUBQ(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64SUBQ(v *Value) bool { b := v.Block _ = b // match: (SUBQ x (MOVQconst [c])) @@ -16399,9 +16195,7 @@ func rewriteValueAMD64_OpAMD64SUBQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SUBQconst(v *Value) bool { // match: (SUBQconst [0] x) // cond: // result: x @@ -16464,9 +16258,7 @@ func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBSD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SUBSD(v *Value) bool { // match: (SUBSD x l:(MOVSDload [off] {sym} ptr mem)) // cond: l.Uses == 1 && canMergeLoad(v, l) && clobber(l) // result: (SUBSDmem x [off] {sym} ptr mem) @@ -16493,9 +16285,7 @@ func rewriteValueAMD64_OpAMD64SUBSD(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBSS(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64SUBSS(v *Value) bool { // match: (SUBSS x l:(MOVSSload [off] {sym} ptr mem)) // cond: l.Uses == 1 && canMergeLoad(v, l) && clobber(l) // result: (SUBSSmem x [off] {sym} ptr mem) @@ -16522,9 +16312,7 @@ func rewriteValueAMD64_OpAMD64SUBSS(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64TESTB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool { // match: (TESTB (MOVLconst [c]) x) // cond: // result: (TESTBconst [c] x) @@ -16557,9 +16345,7 @@ func rewriteValueAMD64_OpAMD64TESTB(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64TESTL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool { // match: (TESTL y x:(SHLL _ _)) // cond: y.Op != OpAMD64SHLL // result: (TESTL x y) @@ -16609,9 +16395,7 @@ func rewriteValueAMD64_OpAMD64TESTL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64TESTQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool { // match: (TESTQ y x:(SHLQ _ _)) // cond: y.Op != OpAMD64SHLQ // result: (TESTQ x y) @@ -16667,9 +16451,7 @@ func rewriteValueAMD64_OpAMD64TESTQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64TESTW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool { // match: (TESTW (MOVLconst [c]) x) // cond: // result: (TESTWconst [c] x) @@ -16702,9 +16484,7 @@ func rewriteValueAMD64_OpAMD64TESTW(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64XADDLlock(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64XADDLlock(v *Value) bool { // match: (XADDLlock [off1] {sym} val (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (XADDLlock [off1+off2] {sym} val ptr mem) @@ -16732,9 +16512,7 @@ func rewriteValueAMD64_OpAMD64XADDLlock(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64XADDQlock(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64XADDQlock(v *Value) bool { // match: (XADDQlock [off1] {sym} val (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (XADDQlock [off1+off2] {sym} val ptr mem) @@ -16762,9 +16540,7 @@ func rewriteValueAMD64_OpAMD64XADDQlock(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64XCHGL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64XCHGL(v *Value) bool { // match: (XCHGL [off1] {sym} val (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (XCHGL [off1+off2] {sym} val ptr mem) @@ -16818,9 +16594,7 @@ func rewriteValueAMD64_OpAMD64XCHGL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64XCHGQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64XCHGQ(v *Value) bool { // match: (XCHGQ [off1] {sym} val (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (XCHGQ [off1+off2] {sym} val ptr mem) @@ -16874,9 +16648,7 @@ func rewriteValueAMD64_OpAMD64XCHGQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64XORL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64XORL(v *Value) bool { // match: (XORL x (MOVLconst [c])) // cond: // result: (XORLconst [c] x) @@ -17135,9 +16907,7 @@ func rewriteValueAMD64_OpAMD64XORL(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64XORLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64XORLconst(v *Value) bool { // match: (XORLconst [c] (XORLconst [d] x)) // cond: // result: (XORLconst [c ^ d] x) @@ -17184,9 +16954,7 @@ func rewriteValueAMD64_OpAMD64XORLconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64XORQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64XORQ(v *Value) bool { // match: (XORQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (XORQconst [c] x) @@ -17335,9 +17103,7 @@ func rewriteValueAMD64_OpAMD64XORQ(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAMD64XORQconst(v *Value) bool { // match: (XORQconst [c] (XORQconst [d] x)) // cond: // result: (XORQconst [c ^ d] x) @@ -17383,9 +17149,7 @@ func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAdd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAdd16(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADDL x y) @@ -17398,9 +17162,7 @@ func rewriteValueAMD64_OpAdd16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAdd32(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADDL x y) @@ -17413,9 +17175,7 @@ func rewriteValueAMD64_OpAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAdd32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAdd32F(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDSS x y) @@ -17428,9 +17188,7 @@ func rewriteValueAMD64_OpAdd32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAdd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAdd64(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADDQ x y) @@ -17443,9 +17201,7 @@ func rewriteValueAMD64_OpAdd64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAdd64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAdd64F(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDSD x y) @@ -17458,9 +17214,7 @@ func rewriteValueAMD64_OpAdd64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAdd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAdd8(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADDL x y) @@ -17473,9 +17227,11 @@ func rewriteValueAMD64_OpAdd8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAddPtr(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAddPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (AddPtr x y) // cond: config.PtrSize == 8 // result: (ADDQ x y) @@ -17506,9 +17262,11 @@ func rewriteValueAMD64_OpAddPtr(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAddr(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAddr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (Addr {sym} base) // cond: config.PtrSize == 8 // result: (LEAQ {sym} base) @@ -17539,9 +17297,7 @@ func rewriteValueAMD64_OpAddr(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAnd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAnd16(v *Value) bool { // match: (And16 x y) // cond: // result: (ANDL x y) @@ -17554,9 +17310,7 @@ func rewriteValueAMD64_OpAnd16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAnd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAnd32(v *Value) bool { // match: (And32 x y) // cond: // result: (ANDL x y) @@ -17569,9 +17323,7 @@ func rewriteValueAMD64_OpAnd32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAnd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAnd64(v *Value) bool { // match: (And64 x y) // cond: // result: (ANDQ x y) @@ -17584,9 +17336,7 @@ func rewriteValueAMD64_OpAnd64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAnd8(v *Value) bool { // match: (And8 x y) // cond: // result: (ANDL x y) @@ -17599,9 +17349,7 @@ func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAndB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAndB(v *Value) bool { // match: (AndB x y) // cond: // result: (ANDL x y) @@ -17614,9 +17362,13 @@ func rewriteValueAMD64_OpAndB(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicAdd32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (AtomicAdd32 ptr val mem) // cond: // result: (AddTupleFirst32 (XADDLlock val ptr mem) val) @@ -17625,7 +17377,7 @@ func rewriteValueAMD64_OpAtomicAdd32(v *Value, config *Config) bool { val := v.Args[1] mem := v.Args[2] v.reset(OpAMD64AddTupleFirst32) - v0 := b.NewValue0(v.Pos, OpAMD64XADDLlock, MakeTuple(config.fe.TypeUInt32(), TypeMem)) + v0 := b.NewValue0(v.Pos, OpAMD64XADDLlock, MakeTuple(fe.TypeUInt32(), TypeMem)) v0.AddArg(val) v0.AddArg(ptr) v0.AddArg(mem) @@ -17634,9 +17386,13 @@ func rewriteValueAMD64_OpAtomicAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicAdd64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (AtomicAdd64 ptr val mem) // cond: // result: (AddTupleFirst64 (XADDQlock val ptr mem) val) @@ -17645,7 +17401,7 @@ func rewriteValueAMD64_OpAtomicAdd64(v *Value, config *Config) bool { val := v.Args[1] mem := v.Args[2] v.reset(OpAMD64AddTupleFirst64) - v0 := b.NewValue0(v.Pos, OpAMD64XADDQlock, MakeTuple(config.fe.TypeUInt64(), TypeMem)) + v0 := b.NewValue0(v.Pos, OpAMD64XADDQlock, MakeTuple(fe.TypeUInt64(), TypeMem)) v0.AddArg(val) v0.AddArg(ptr) v0.AddArg(mem) @@ -17654,9 +17410,7 @@ func rewriteValueAMD64_OpAtomicAdd64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAtomicAnd8(v *Value) bool { // match: (AtomicAnd8 ptr val mem) // cond: // result: (ANDBlock ptr val mem) @@ -17671,9 +17425,7 @@ func rewriteValueAMD64_OpAtomicAnd8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (CMPXCHGLlock ptr old new_ mem) @@ -17690,9 +17442,7 @@ func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *Value) bool { // match: (AtomicCompareAndSwap64 ptr old new_ mem) // cond: // result: (CMPXCHGQlock ptr old new_ mem) @@ -17709,9 +17459,7 @@ func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicExchange32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAtomicExchange32(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (XCHGL val ptr mem) @@ -17726,9 +17474,7 @@ func rewriteValueAMD64_OpAtomicExchange32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicExchange64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAtomicExchange64(v *Value) bool { // match: (AtomicExchange64 ptr val mem) // cond: // result: (XCHGQ val ptr mem) @@ -17743,9 +17489,7 @@ func rewriteValueAMD64_OpAtomicExchange64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicLoad32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAtomicLoad32(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (MOVLatomicload ptr mem) @@ -17758,9 +17502,7 @@ func rewriteValueAMD64_OpAtomicLoad32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicLoad64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAtomicLoad64(v *Value) bool { // match: (AtomicLoad64 ptr mem) // cond: // result: (MOVQatomicload ptr mem) @@ -17773,9 +17515,11 @@ func rewriteValueAMD64_OpAtomicLoad64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicLoadPtr(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAtomicLoadPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (AtomicLoadPtr ptr mem) // cond: config.PtrSize == 8 // result: (MOVQatomicload ptr mem) @@ -17806,9 +17550,7 @@ func rewriteValueAMD64_OpAtomicLoadPtr(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAtomicOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAtomicOr8(v *Value) bool { // match: (AtomicOr8 ptr val mem) // cond: // result: (ORBlock ptr val mem) @@ -17823,18 +17565,22 @@ func rewriteValueAMD64_OpAtomicOr8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicStore32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAtomicStore32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (AtomicStore32 ptr val mem) // cond: - // result: (Select1 (XCHGL <MakeTuple(config.Frontend().TypeUInt32(),TypeMem)> val ptr mem)) + // result: (Select1 (XCHGL <MakeTuple(fe.TypeUInt32(),TypeMem)> val ptr mem)) for { ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(config.Frontend().TypeUInt32(), TypeMem)) + v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(fe.TypeUInt32(), TypeMem)) v0.AddArg(val) v0.AddArg(ptr) v0.AddArg(mem) @@ -17842,18 +17588,22 @@ func rewriteValueAMD64_OpAtomicStore32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicStore64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAtomicStore64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (AtomicStore64 ptr val mem) // cond: - // result: (Select1 (XCHGQ <MakeTuple(config.Frontend().TypeUInt64(),TypeMem)> val ptr mem)) + // result: (Select1 (XCHGQ <MakeTuple(fe.TypeUInt64(),TypeMem)> val ptr mem)) for { ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(config.Frontend().TypeUInt64(), TypeMem)) + v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(fe.TypeUInt64(), TypeMem)) v0.AddArg(val) v0.AddArg(ptr) v0.AddArg(mem) @@ -17861,12 +17611,16 @@ func rewriteValueAMD64_OpAtomicStore64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (AtomicStorePtrNoWB ptr val mem) // cond: config.PtrSize == 8 - // result: (Select1 (XCHGQ <MakeTuple(config.Frontend().TypeBytePtr(),TypeMem)> val ptr mem)) + // result: (Select1 (XCHGQ <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem)) for { ptr := v.Args[0] val := v.Args[1] @@ -17875,7 +17629,7 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { break } v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(config.Frontend().TypeBytePtr(), TypeMem)) + v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(fe.TypeBytePtr(), TypeMem)) v0.AddArg(val) v0.AddArg(ptr) v0.AddArg(mem) @@ -17884,7 +17638,7 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { } // match: (AtomicStorePtrNoWB ptr val mem) // cond: config.PtrSize == 4 - // result: (Select1 (XCHGL <MakeTuple(config.Frontend().TypeBytePtr(),TypeMem)> val ptr mem)) + // result: (Select1 (XCHGL <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem)) for { ptr := v.Args[0] val := v.Args[1] @@ -17893,7 +17647,7 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { break } v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(config.Frontend().TypeBytePtr(), TypeMem)) + v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(fe.TypeBytePtr(), TypeMem)) v0.AddArg(val) v0.AddArg(ptr) v0.AddArg(mem) @@ -17902,9 +17656,7 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpAvg64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpAvg64u(v *Value) bool { // match: (Avg64u x y) // cond: // result: (AVGQU x y) @@ -17917,24 +17669,32 @@ func rewriteValueAMD64_OpAvg64u(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpBitLen32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpBitLen32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (BitLen32 x) // cond: - // result: (BitLen64 (MOVLQZX <config.Frontend().TypeUInt64()> x)) + // result: (BitLen64 (MOVLQZX <fe.TypeUInt64()> x)) for { x := v.Args[0] v.reset(OpBitLen64) - v0 := b.NewValue0(v.Pos, OpAMD64MOVLQZX, config.Frontend().TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVLQZX, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpBitLen64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpBitLen64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (BitLen64 <t> x) // cond: // result: (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <TypeFlags> (BSRQ x)))) @@ -17945,7 +17705,7 @@ func rewriteValueAMD64_OpBitLen64(v *Value, config *Config) bool { v.AuxInt = 1 v0 := b.NewValue0(v.Pos, OpAMD64CMOVQEQ, t) v1 := b.NewValue0(v.Pos, OpSelect0, t) - v2 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(config.fe.TypeUInt64(), TypeFlags)) + v2 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) v2.AddArg(x) v1.AddArg(v2) v0.AddArg(v1) @@ -17953,7 +17713,7 @@ func rewriteValueAMD64_OpBitLen64(v *Value, config *Config) bool { v3.AuxInt = -1 v0.AddArg(v3) v4 := b.NewValue0(v.Pos, OpSelect1, TypeFlags) - v5 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(config.fe.TypeUInt64(), TypeFlags)) + v5 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) v5.AddArg(x) v4.AddArg(v5) v0.AddArg(v4) @@ -17961,9 +17721,7 @@ func rewriteValueAMD64_OpBitLen64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpBswap32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpBswap32(v *Value) bool { // match: (Bswap32 x) // cond: // result: (BSWAPL x) @@ -17974,9 +17732,7 @@ func rewriteValueAMD64_OpBswap32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpBswap64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpBswap64(v *Value) bool { // match: (Bswap64 x) // cond: // result: (BSWAPQ x) @@ -17987,9 +17743,7 @@ func rewriteValueAMD64_OpBswap64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpClosureCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpClosureCall(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -18006,9 +17760,7 @@ func rewriteValueAMD64_OpClosureCall(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCom16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCom16(v *Value) bool { // match: (Com16 x) // cond: // result: (NOTL x) @@ -18019,9 +17771,7 @@ func rewriteValueAMD64_OpCom16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCom32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCom32(v *Value) bool { // match: (Com32 x) // cond: // result: (NOTL x) @@ -18032,9 +17782,7 @@ func rewriteValueAMD64_OpCom32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCom64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCom64(v *Value) bool { // match: (Com64 x) // cond: // result: (NOTQ x) @@ -18045,9 +17793,7 @@ func rewriteValueAMD64_OpCom64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCom8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCom8(v *Value) bool { // match: (Com8 x) // cond: // result: (NOTL x) @@ -18058,9 +17804,7 @@ func rewriteValueAMD64_OpCom8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpConst16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpConst16(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVLconst [val]) @@ -18071,9 +17815,7 @@ func rewriteValueAMD64_OpConst16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpConst32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpConst32(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVLconst [val]) @@ -18084,9 +17826,7 @@ func rewriteValueAMD64_OpConst32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpConst32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpConst32F(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVSSconst [val]) @@ -18097,9 +17837,7 @@ func rewriteValueAMD64_OpConst32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpConst64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpConst64(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVQconst [val]) @@ -18110,9 +17848,7 @@ func rewriteValueAMD64_OpConst64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpConst64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpConst64F(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVSDconst [val]) @@ -18123,9 +17859,7 @@ func rewriteValueAMD64_OpConst64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpConst8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpConst8(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVLconst [val]) @@ -18136,9 +17870,7 @@ func rewriteValueAMD64_OpConst8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpConstBool(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpConstBool(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVLconst [b]) @@ -18149,9 +17881,11 @@ func rewriteValueAMD64_OpConstBool(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpConstNil(v *Value, config *Config) bool { +func rewriteValueAMD64_OpConstNil(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (ConstNil) // cond: config.PtrSize == 8 // result: (MOVQconst [0]) @@ -18176,9 +17910,11 @@ func rewriteValueAMD64_OpConstNil(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { +func rewriteValueAMD64_OpConvert(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (Convert <t> x mem) // cond: config.PtrSize == 8 // result: (MOVQconvert <t> x mem) @@ -18213,18 +17949,22 @@ func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpCtz32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpCtz32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Ctz32 x) // cond: - // result: (Select0 (BSFQ (ORQ <config.Frontend().TypeUInt64()> (MOVQconst [1<<32]) x))) + // result: (Select0 (BSFQ (ORQ <fe.TypeUInt64()> (MOVQconst [1<<32]) x))) for { x := v.Args[0] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(config.fe.TypeUInt64(), TypeFlags)) - v1 := b.NewValue0(v.Pos, OpAMD64ORQ, config.Frontend().TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) + v1 := b.NewValue0(v.Pos, OpAMD64ORQ, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v2.AuxInt = 1 << 32 v1.AddArg(v2) v1.AddArg(x) @@ -18233,9 +17973,13 @@ func rewriteValueAMD64_OpCtz32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCtz64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpCtz64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Ctz64 <t> x) // cond: // result: (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <TypeFlags> (BSFQ x))) @@ -18244,7 +17988,7 @@ func rewriteValueAMD64_OpCtz64(v *Value, config *Config) bool { x := v.Args[0] v.reset(OpAMD64CMOVQEQ) v0 := b.NewValue0(v.Pos, OpSelect0, t) - v1 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(config.fe.TypeUInt64(), TypeFlags)) + v1 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) @@ -18252,16 +17996,14 @@ func rewriteValueAMD64_OpCtz64(v *Value, config *Config) bool { v2.AuxInt = 64 v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpSelect1, TypeFlags) - v4 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(config.fe.TypeUInt64(), TypeFlags)) + v4 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) v4.AddArg(x) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueAMD64_OpCvt32Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt32Fto32(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (CVTTSS2SL x) @@ -18272,9 +18014,7 @@ func rewriteValueAMD64_OpCvt32Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCvt32Fto64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt32Fto64(v *Value) bool { // match: (Cvt32Fto64 x) // cond: // result: (CVTTSS2SQ x) @@ -18285,9 +18025,7 @@ func rewriteValueAMD64_OpCvt32Fto64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCvt32Fto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt32Fto64F(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (CVTSS2SD x) @@ -18298,9 +18036,7 @@ func rewriteValueAMD64_OpCvt32Fto64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCvt32to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt32to32F(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (CVTSL2SS x) @@ -18311,9 +18047,7 @@ func rewriteValueAMD64_OpCvt32to32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCvt32to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt32to64F(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (CVTSL2SD x) @@ -18324,9 +18058,7 @@ func rewriteValueAMD64_OpCvt32to64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCvt64Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt64Fto32(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (CVTTSD2SL x) @@ -18337,9 +18069,7 @@ func rewriteValueAMD64_OpCvt64Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCvt64Fto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt64Fto32F(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (CVTSD2SS x) @@ -18350,9 +18080,7 @@ func rewriteValueAMD64_OpCvt64Fto32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCvt64Fto64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt64Fto64(v *Value) bool { // match: (Cvt64Fto64 x) // cond: // result: (CVTTSD2SQ x) @@ -18363,9 +18091,7 @@ func rewriteValueAMD64_OpCvt64Fto64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCvt64to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt64to32F(v *Value) bool { // match: (Cvt64to32F x) // cond: // result: (CVTSQ2SS x) @@ -18376,9 +18102,7 @@ func rewriteValueAMD64_OpCvt64to32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpCvt64to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpCvt64to64F(v *Value) bool { // match: (Cvt64to64F x) // cond: // result: (CVTSQ2SD x) @@ -18389,9 +18113,7 @@ func rewriteValueAMD64_OpCvt64to64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpDiv128u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpDiv128u(v *Value) bool { // match: (Div128u xhi xlo y) // cond: // result: (DIVQU2 xhi xlo y) @@ -18406,9 +18128,13 @@ func rewriteValueAMD64_OpDiv128u(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpDiv16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpDiv16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16 x y) // cond: // result: (Select0 (DIVW x y)) @@ -18416,16 +18142,20 @@ func rewriteValueAMD64_OpDiv16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(config.fe.TypeInt16(), config.fe.TypeInt16())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpDiv16u(v *Value, config *Config) bool { +func rewriteValueAMD64_OpDiv16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16u x y) // cond: // result: (Select0 (DIVWU x y)) @@ -18433,16 +18163,20 @@ func rewriteValueAMD64_OpDiv16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(config.fe.TypeUInt16(), config.fe.TypeUInt16())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpDiv32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpDiv32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32 x y) // cond: // result: (Select0 (DIVL x y)) @@ -18450,16 +18184,14 @@ func rewriteValueAMD64_OpDiv32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(config.fe.TypeInt32(), config.fe.TypeInt32())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpDiv32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpDiv32F(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVSS x y) @@ -18472,9 +18204,13 @@ func rewriteValueAMD64_OpDiv32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpDiv32u(v *Value, config *Config) bool { +func rewriteValueAMD64_OpDiv32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32u x y) // cond: // result: (Select0 (DIVLU x y)) @@ -18482,16 +18218,20 @@ func rewriteValueAMD64_OpDiv32u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpDiv64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpDiv64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div64 x y) // cond: // result: (Select0 (DIVQ x y)) @@ -18499,16 +18239,14 @@ func rewriteValueAMD64_OpDiv64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpDiv64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpDiv64F(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVSD x y) @@ -18521,9 +18259,13 @@ func rewriteValueAMD64_OpDiv64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpDiv64u(v *Value, config *Config) bool { +func rewriteValueAMD64_OpDiv64u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div64u x y) // cond: // result: (Select0 (DIVQU x y)) @@ -18531,16 +18273,20 @@ func rewriteValueAMD64_OpDiv64u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpDiv8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpDiv8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8 x y) // cond: // result: (Select0 (DIVW (SignExt8to16 x) (SignExt8to16 y))) @@ -18548,20 +18294,24 @@ func rewriteValueAMD64_OpDiv8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(config.fe.TypeInt16(), config.fe.TypeInt16())) - v1 := b.NewValue0(v.Pos, OpSignExt8to16, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16())) + v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to16, config.fe.TypeInt16()) + v2 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpDiv8u(v *Value, config *Config) bool { +func rewriteValueAMD64_OpDiv8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8u x y) // cond: // result: (Select0 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))) @@ -18569,18 +18319,18 @@ func rewriteValueAMD64_OpDiv8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(config.fe.TypeUInt16(), config.fe.TypeUInt16())) - v1 := b.NewValue0(v.Pos, OpZeroExt8to16, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16())) + v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to16, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpEq16(v *Value) bool { b := v.Block _ = b // match: (Eq16 x y) @@ -18597,7 +18347,7 @@ func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpEq32(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -18614,7 +18364,7 @@ func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpEq32F(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -18631,7 +18381,7 @@ func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpEq64(v *Value) bool { b := v.Block _ = b // match: (Eq64 x y) @@ -18648,7 +18398,7 @@ func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpEq64F(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -18665,7 +18415,7 @@ func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpEq8(v *Value) bool { b := v.Block _ = b // match: (Eq8 x y) @@ -18682,7 +18432,7 @@ func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpEqB(v *Value, config *Config) bool { +func rewriteValueAMD64_OpEqB(v *Value) bool { b := v.Block _ = b // match: (EqB x y) @@ -18699,9 +18449,11 @@ func rewriteValueAMD64_OpEqB(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool { +func rewriteValueAMD64_OpEqPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (EqPtr x y) // cond: config.PtrSize == 8 // result: (SETEQ (CMPQ x y)) @@ -18736,7 +18488,7 @@ func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq16(v *Value) bool { b := v.Block _ = b // match: (Geq16 x y) @@ -18753,7 +18505,7 @@ func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq16U(v *Value) bool { b := v.Block _ = b // match: (Geq16U x y) @@ -18770,7 +18522,7 @@ func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq32(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -18787,7 +18539,7 @@ func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq32F(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -18804,7 +18556,7 @@ func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq32U(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -18821,7 +18573,7 @@ func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq64(v *Value) bool { b := v.Block _ = b // match: (Geq64 x y) @@ -18838,7 +18590,7 @@ func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq64F(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -18855,7 +18607,7 @@ func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq64U(v *Value) bool { b := v.Block _ = b // match: (Geq64U x y) @@ -18872,7 +18624,7 @@ func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq8(v *Value) bool { b := v.Block _ = b // match: (Geq8 x y) @@ -18889,7 +18641,7 @@ func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGeq8U(v *Value) bool { b := v.Block _ = b // match: (Geq8U x y) @@ -18906,9 +18658,7 @@ func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGetClosurePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -18917,9 +18667,7 @@ func rewriteValueAMD64_OpGetClosurePtr(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGetG(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpGetG(v *Value) bool { // match: (GetG mem) // cond: // result: (LoweredGetG mem) @@ -18930,7 +18678,7 @@ func rewriteValueAMD64_OpGetG(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater16(v *Value) bool { b := v.Block _ = b // match: (Greater16 x y) @@ -18947,7 +18695,7 @@ func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater16U(v *Value) bool { b := v.Block _ = b // match: (Greater16U x y) @@ -18964,7 +18712,7 @@ func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater32(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -18981,7 +18729,7 @@ func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater32F(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -18998,7 +18746,7 @@ func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater32U(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -19015,7 +18763,7 @@ func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater64(v *Value) bool { b := v.Block _ = b // match: (Greater64 x y) @@ -19032,7 +18780,7 @@ func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater64F(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -19049,7 +18797,7 @@ func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater64U(v *Value) bool { b := v.Block _ = b // match: (Greater64U x y) @@ -19066,7 +18814,7 @@ func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater8(v *Value) bool { b := v.Block _ = b // match: (Greater8 x y) @@ -19083,7 +18831,7 @@ func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpGreater8U(v *Value) bool { b := v.Block _ = b // match: (Greater8U x y) @@ -19100,9 +18848,7 @@ func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpHmul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpHmul32(v *Value) bool { // match: (Hmul32 x y) // cond: // result: (HMULL x y) @@ -19115,9 +18861,7 @@ func rewriteValueAMD64_OpHmul32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpHmul32u(v *Value) bool { // match: (Hmul32u x y) // cond: // result: (HMULLU x y) @@ -19130,9 +18874,7 @@ func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpHmul64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpHmul64(v *Value) bool { // match: (Hmul64 x y) // cond: // result: (HMULQ x y) @@ -19145,9 +18887,7 @@ func rewriteValueAMD64_OpHmul64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpHmul64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpHmul64u(v *Value) bool { // match: (Hmul64u x y) // cond: // result: (HMULQU x y) @@ -19160,9 +18900,7 @@ func rewriteValueAMD64_OpHmul64u(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpInt64Hi(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpInt64Hi(v *Value) bool { // match: (Int64Hi x) // cond: // result: (SHRQconst [32] x) @@ -19174,9 +18912,7 @@ func rewriteValueAMD64_OpInt64Hi(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpInterCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpInterCall(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -19191,7 +18927,7 @@ func rewriteValueAMD64_OpInterCall(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool { +func rewriteValueAMD64_OpIsInBounds(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -19208,9 +18944,11 @@ func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool { +func rewriteValueAMD64_OpIsNonNil(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (IsNonNil p) // cond: config.PtrSize == 8 // result: (SETNE (TESTQ p p)) @@ -19243,7 +18981,7 @@ func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool { +func rewriteValueAMD64_OpIsSliceInBounds(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -19260,7 +18998,7 @@ func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq16(v *Value) bool { b := v.Block _ = b // match: (Leq16 x y) @@ -19277,7 +19015,7 @@ func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq16U(v *Value) bool { b := v.Block _ = b // match: (Leq16U x y) @@ -19294,7 +19032,7 @@ func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq32(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -19311,7 +19049,7 @@ func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq32F(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -19328,7 +19066,7 @@ func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq32U(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -19345,7 +19083,7 @@ func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq64(v *Value) bool { b := v.Block _ = b // match: (Leq64 x y) @@ -19362,7 +19100,7 @@ func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq64F(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -19379,7 +19117,7 @@ func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq64U(v *Value) bool { b := v.Block _ = b // match: (Leq64U x y) @@ -19396,7 +19134,7 @@ func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq8(v *Value) bool { b := v.Block _ = b // match: (Leq8 x y) @@ -19413,7 +19151,7 @@ func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLeq8U(v *Value) bool { b := v.Block _ = b // match: (Leq8U x y) @@ -19430,7 +19168,7 @@ func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess16(v *Value) bool { b := v.Block _ = b // match: (Less16 x y) @@ -19447,7 +19185,7 @@ func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess16U(v *Value) bool { b := v.Block _ = b // match: (Less16U x y) @@ -19464,7 +19202,7 @@ func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess32(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -19481,7 +19219,7 @@ func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess32F(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -19498,7 +19236,7 @@ func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess32U(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -19515,7 +19253,7 @@ func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess64(v *Value) bool { b := v.Block _ = b // match: (Less64 x y) @@ -19532,7 +19270,7 @@ func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess64F(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -19549,7 +19287,7 @@ func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess64U(v *Value) bool { b := v.Block _ = b // match: (Less64U x y) @@ -19566,7 +19304,7 @@ func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess8(v *Value) bool { b := v.Block _ = b // match: (Less8 x y) @@ -19583,7 +19321,7 @@ func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLess8U(v *Value) bool { b := v.Block _ = b // match: (Less8U x y) @@ -19600,9 +19338,11 @@ func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLoad(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLoad(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (Load <t> ptr mem) // cond: (is64BitInt(t) || isPtr(t) && config.PtrSize == 8) // result: (MOVQload ptr mem) @@ -19695,7 +19435,7 @@ func rewriteValueAMD64_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh16x16(v *Value) bool { b := v.Block _ = b // match: (Lsh16x16 <t> x y) @@ -19719,7 +19459,7 @@ func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh16x32(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 <t> x y) @@ -19743,7 +19483,7 @@ func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh16x64(v *Value) bool { b := v.Block _ = b // match: (Lsh16x64 <t> x y) @@ -19767,7 +19507,7 @@ func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh16x8(v *Value) bool { b := v.Block _ = b // match: (Lsh16x8 <t> x y) @@ -19791,7 +19531,7 @@ func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh32x16(v *Value) bool { b := v.Block _ = b // match: (Lsh32x16 <t> x y) @@ -19815,7 +19555,7 @@ func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh32x32(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 <t> x y) @@ -19839,7 +19579,7 @@ func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh32x64(v *Value) bool { b := v.Block _ = b // match: (Lsh32x64 <t> x y) @@ -19863,7 +19603,7 @@ func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh32x8(v *Value) bool { b := v.Block _ = b // match: (Lsh32x8 <t> x y) @@ -19887,7 +19627,7 @@ func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh64x16(v *Value) bool { b := v.Block _ = b // match: (Lsh64x16 <t> x y) @@ -19911,7 +19651,7 @@ func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh64x32(v *Value) bool { b := v.Block _ = b // match: (Lsh64x32 <t> x y) @@ -19935,7 +19675,7 @@ func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh64x64(v *Value) bool { b := v.Block _ = b // match: (Lsh64x64 <t> x y) @@ -19959,7 +19699,7 @@ func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh64x8(v *Value) bool { b := v.Block _ = b // match: (Lsh64x8 <t> x y) @@ -19983,7 +19723,7 @@ func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh8x16(v *Value) bool { b := v.Block _ = b // match: (Lsh8x16 <t> x y) @@ -20007,7 +19747,7 @@ func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh8x32(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 <t> x y) @@ -20031,7 +19771,7 @@ func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh8x64(v *Value) bool { b := v.Block _ = b // match: (Lsh8x64 <t> x y) @@ -20055,7 +19795,7 @@ func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpLsh8x8(v *Value) bool { b := v.Block _ = b // match: (Lsh8x8 <t> x y) @@ -20079,9 +19819,13 @@ func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpMod16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpMod16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16 x y) // cond: // result: (Select1 (DIVW x y)) @@ -20089,16 +19833,20 @@ func rewriteValueAMD64_OpMod16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(config.fe.TypeInt16(), config.fe.TypeInt16())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpMod16u(v *Value, config *Config) bool { +func rewriteValueAMD64_OpMod16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16u x y) // cond: // result: (Select1 (DIVWU x y)) @@ -20106,16 +19854,20 @@ func rewriteValueAMD64_OpMod16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(config.fe.TypeUInt16(), config.fe.TypeUInt16())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpMod32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpMod32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32 x y) // cond: // result: (Select1 (DIVL x y)) @@ -20123,16 +19875,20 @@ func rewriteValueAMD64_OpMod32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(config.fe.TypeInt32(), config.fe.TypeInt32())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpMod32u(v *Value, config *Config) bool { +func rewriteValueAMD64_OpMod32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32u x y) // cond: // result: (Select1 (DIVLU x y)) @@ -20140,16 +19896,20 @@ func rewriteValueAMD64_OpMod32u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpMod64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpMod64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod64 x y) // cond: // result: (Select1 (DIVQ x y)) @@ -20157,16 +19917,20 @@ func rewriteValueAMD64_OpMod64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpMod64u(v *Value, config *Config) bool { +func rewriteValueAMD64_OpMod64u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod64u x y) // cond: // result: (Select1 (DIVQU x y)) @@ -20174,16 +19938,20 @@ func rewriteValueAMD64_OpMod64u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) + v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpMod8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpMod8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8 x y) // cond: // result: (Select1 (DIVW (SignExt8to16 x) (SignExt8to16 y))) @@ -20191,20 +19959,24 @@ func rewriteValueAMD64_OpMod8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(config.fe.TypeInt16(), config.fe.TypeInt16())) - v1 := b.NewValue0(v.Pos, OpSignExt8to16, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16())) + v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to16, config.fe.TypeInt16()) + v2 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpMod8u(v *Value, config *Config) bool { +func rewriteValueAMD64_OpMod8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8u x y) // cond: // result: (Select1 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))) @@ -20212,20 +19984,24 @@ func rewriteValueAMD64_OpMod8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(config.fe.TypeUInt16(), config.fe.TypeUInt16())) - v1 := b.NewValue0(v.Pos, OpZeroExt8to16, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16())) + v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to16, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { +func rewriteValueAMD64_OpMove(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Move [0] _ _ mem) // cond: // result: mem @@ -20251,7 +20027,7 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpAMD64MOVBstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, fe.TypeUInt8()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -20270,7 +20046,7 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpAMD64MOVWstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -20289,7 +20065,7 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpAMD64MOVLstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -20308,7 +20084,7 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpAMD64MOVQstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -20347,14 +20123,14 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { v.reset(OpAMD64MOVBstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, fe.TypeUInt8()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpAMD64MOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpAMD64MOVWload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -20375,14 +20151,14 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { v.reset(OpAMD64MOVBstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, fe.TypeUInt8()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -20403,14 +20179,14 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { v.reset(OpAMD64MOVWstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -20431,14 +20207,14 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { v.reset(OpAMD64MOVLstore) v.AuxInt = 3 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v0.AuxInt = 3 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -20460,14 +20236,14 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { v.reset(OpAMD64MOVQstore) v.AuxInt = s - 8 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v0.AuxInt = s - 8 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpAMD64MOVQload, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -20498,7 +20274,7 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem) v2.AddArg(dst) - v3 := b.NewValue0(v.Pos, OpAMD64MOVQload, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v3.AddArg(src) v3.AddArg(mem) v2.AddArg(v3) @@ -20569,7 +20345,7 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { v.reset(OpAMD64REPMOVSQ) v.AddArg(dst) v.AddArg(src) - v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0.AuxInt = s / 8 v.AddArg(v0) v.AddArg(mem) @@ -20577,9 +20353,7 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpMul16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpMul16(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULL x y) @@ -20592,9 +20366,7 @@ func rewriteValueAMD64_OpMul16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpMul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpMul32(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULL x y) @@ -20607,9 +20379,7 @@ func rewriteValueAMD64_OpMul32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpMul32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpMul32F(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULSS x y) @@ -20622,9 +20392,7 @@ func rewriteValueAMD64_OpMul32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpMul64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpMul64(v *Value) bool { // match: (Mul64 x y) // cond: // result: (MULQ x y) @@ -20637,9 +20405,7 @@ func rewriteValueAMD64_OpMul64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpMul64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpMul64F(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULSD x y) @@ -20652,9 +20418,7 @@ func rewriteValueAMD64_OpMul64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpMul64uhilo(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpMul64uhilo(v *Value) bool { // match: (Mul64uhilo x y) // cond: // result: (MULQU2 x y) @@ -20667,9 +20431,7 @@ func rewriteValueAMD64_OpMul64uhilo(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpMul8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpMul8(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULL x y) @@ -20682,9 +20444,7 @@ func rewriteValueAMD64_OpMul8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeg16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpNeg16(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEGL x) @@ -20695,9 +20455,7 @@ func rewriteValueAMD64_OpNeg16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeg32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpNeg32(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEGL x) @@ -20708,25 +20466,27 @@ func rewriteValueAMD64_OpNeg32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeg32F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeg32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neg32F x) // cond: - // result: (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> [f2i(math.Copysign(0, -1))])) + // result: (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))])) for { x := v.Args[0] v.reset(OpAMD64PXOR) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpAMD64MOVSSconst, config.Frontend().TypeFloat32()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVSSconst, fe.TypeFloat32()) v0.AuxInt = f2i(math.Copysign(0, -1)) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpNeg64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpNeg64(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEGQ x) @@ -20737,25 +20497,27 @@ func rewriteValueAMD64_OpNeg64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeg64F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeg64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neg64F x) // cond: - // result: (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> [f2i(math.Copysign(0, -1))])) + // result: (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))])) for { x := v.Args[0] v.reset(OpAMD64PXOR) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpAMD64MOVSDconst, config.Frontend().TypeFloat64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVSDconst, fe.TypeFloat64()) v0.AuxInt = f2i(math.Copysign(0, -1)) v.AddArg(v0) return true } } -func rewriteValueAMD64_OpNeg8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpNeg8(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEGL x) @@ -20766,7 +20528,7 @@ func rewriteValueAMD64_OpNeg8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeq16(v *Value) bool { b := v.Block _ = b // match: (Neq16 x y) @@ -20783,7 +20545,7 @@ func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeq32(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -20800,7 +20562,7 @@ func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeq32F(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -20817,7 +20579,7 @@ func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeq64(v *Value) bool { b := v.Block _ = b // match: (Neq64 x y) @@ -20834,7 +20596,7 @@ func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeq64F(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -20851,7 +20613,7 @@ func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeq8(v *Value) bool { b := v.Block _ = b // match: (Neq8 x y) @@ -20868,7 +20630,7 @@ func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeqB(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeqB(v *Value) bool { b := v.Block _ = b // match: (NeqB x y) @@ -20885,9 +20647,11 @@ func rewriteValueAMD64_OpNeqB(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool { +func rewriteValueAMD64_OpNeqPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (NeqPtr x y) // cond: config.PtrSize == 8 // result: (SETNE (CMPQ x y)) @@ -20922,9 +20686,7 @@ func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpNilCheck(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpNilCheck(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -20937,9 +20699,7 @@ func rewriteValueAMD64_OpNilCheck(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpNot(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpNot(v *Value) bool { // match: (Not x) // cond: // result: (XORLconst [1] x) @@ -20951,9 +20711,13 @@ func rewriteValueAMD64_OpNot(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool { +func rewriteValueAMD64_OpOffPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (OffPtr [off] ptr) // cond: config.PtrSize == 8 && is32Bit(off) // result: (ADDQconst [off] ptr) @@ -20978,7 +20742,7 @@ func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool { break } v.reset(OpAMD64ADDQ) - v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0.AuxInt = off v.AddArg(v0) v.AddArg(ptr) @@ -21000,9 +20764,7 @@ func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpOr16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpOr16(v *Value) bool { // match: (Or16 x y) // cond: // result: (ORL x y) @@ -21015,9 +20777,7 @@ func rewriteValueAMD64_OpOr16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpOr32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpOr32(v *Value) bool { // match: (Or32 x y) // cond: // result: (ORL x y) @@ -21030,9 +20790,7 @@ func rewriteValueAMD64_OpOr32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpOr64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpOr64(v *Value) bool { // match: (Or64 x y) // cond: // result: (ORQ x y) @@ -21045,9 +20803,7 @@ func rewriteValueAMD64_OpOr64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpOr8(v *Value) bool { // match: (Or8 x y) // cond: // result: (ORL x y) @@ -21060,9 +20816,7 @@ func rewriteValueAMD64_OpOr8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpOrB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpOrB(v *Value) bool { // match: (OrB x y) // cond: // result: (ORL x y) @@ -21075,9 +20829,7 @@ func rewriteValueAMD64_OpOrB(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpRound32F(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -21089,9 +20841,7 @@ func rewriteValueAMD64_OpRound32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpRound64F(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -21103,7 +20853,7 @@ func rewriteValueAMD64_OpRound64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh16Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux16 <t> x y) @@ -21127,7 +20877,7 @@ func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh16Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux32 <t> x y) @@ -21151,7 +20901,7 @@ func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh16Ux64(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux64 <t> x y) @@ -21175,7 +20925,7 @@ func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh16Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux8 <t> x y) @@ -21199,7 +20949,7 @@ func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh16x16(v *Value) bool { b := v.Block _ = b // match: (Rsh16x16 <t> x y) @@ -21226,7 +20976,7 @@ func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh16x32(v *Value) bool { b := v.Block _ = b // match: (Rsh16x32 <t> x y) @@ -21253,7 +21003,7 @@ func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh16x64(v *Value) bool { b := v.Block _ = b // match: (Rsh16x64 <t> x y) @@ -21280,7 +21030,7 @@ func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh16x8(v *Value) bool { b := v.Block _ = b // match: (Rsh16x8 <t> x y) @@ -21307,7 +21057,7 @@ func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh32Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux16 <t> x y) @@ -21331,7 +21081,7 @@ func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh32Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 <t> x y) @@ -21355,7 +21105,7 @@ func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh32Ux64(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux64 <t> x y) @@ -21379,7 +21129,7 @@ func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh32Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux8 <t> x y) @@ -21403,7 +21153,7 @@ func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh32x16(v *Value) bool { b := v.Block _ = b // match: (Rsh32x16 <t> x y) @@ -21430,7 +21180,7 @@ func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh32x32(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 <t> x y) @@ -21457,7 +21207,7 @@ func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh32x64(v *Value) bool { b := v.Block _ = b // match: (Rsh32x64 <t> x y) @@ -21484,7 +21234,7 @@ func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh32x8(v *Value) bool { b := v.Block _ = b // match: (Rsh32x8 <t> x y) @@ -21511,7 +21261,7 @@ func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh64Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux16 <t> x y) @@ -21535,7 +21285,7 @@ func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh64Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux32 <t> x y) @@ -21559,7 +21309,7 @@ func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh64Ux64(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux64 <t> x y) @@ -21583,7 +21333,7 @@ func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh64Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux8 <t> x y) @@ -21607,7 +21357,7 @@ func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh64x16(v *Value) bool { b := v.Block _ = b // match: (Rsh64x16 <t> x y) @@ -21634,7 +21384,7 @@ func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh64x32(v *Value) bool { b := v.Block _ = b // match: (Rsh64x32 <t> x y) @@ -21661,7 +21411,7 @@ func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh64x64(v *Value) bool { b := v.Block _ = b // match: (Rsh64x64 <t> x y) @@ -21688,7 +21438,7 @@ func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh64x8(v *Value) bool { b := v.Block _ = b // match: (Rsh64x8 <t> x y) @@ -21715,7 +21465,7 @@ func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh8Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux16 <t> x y) @@ -21739,7 +21489,7 @@ func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh8Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux32 <t> x y) @@ -21763,7 +21513,7 @@ func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh8Ux64(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux64 <t> x y) @@ -21787,7 +21537,7 @@ func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh8Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux8 <t> x y) @@ -21811,7 +21561,7 @@ func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh8x16(v *Value) bool { b := v.Block _ = b // match: (Rsh8x16 <t> x y) @@ -21838,7 +21588,7 @@ func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh8x32(v *Value) bool { b := v.Block _ = b // match: (Rsh8x32 <t> x y) @@ -21865,7 +21615,7 @@ func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh8x64(v *Value) bool { b := v.Block _ = b // match: (Rsh8x64 <t> x y) @@ -21892,7 +21642,7 @@ func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { +func rewriteValueAMD64_OpRsh8x8(v *Value) bool { b := v.Block _ = b // match: (Rsh8x8 <t> x y) @@ -21919,7 +21669,7 @@ func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSelect0(v *Value, config *Config) bool { +func rewriteValueAMD64_OpSelect0(v *Value) bool { b := v.Block _ = b // match: (Select0 <t> (AddTupleFirst32 tuple val)) @@ -21960,9 +21710,7 @@ func rewriteValueAMD64_OpSelect0(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpSelect1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSelect1(v *Value) bool { // match: (Select1 (AddTupleFirst32 tuple _ )) // cond: // result: (Select1 tuple) @@ -21991,9 +21739,7 @@ func rewriteValueAMD64_OpSelect1(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpSignExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSignExt16to32(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVWQSX x) @@ -22004,9 +21750,7 @@ func rewriteValueAMD64_OpSignExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSignExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSignExt16to64(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVWQSX x) @@ -22017,9 +21761,7 @@ func rewriteValueAMD64_OpSignExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSignExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSignExt32to64(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVLQSX x) @@ -22030,9 +21772,7 @@ func rewriteValueAMD64_OpSignExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSignExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSignExt8to16(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBQSX x) @@ -22043,9 +21783,7 @@ func rewriteValueAMD64_OpSignExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSignExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSignExt8to32(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBQSX x) @@ -22056,9 +21794,7 @@ func rewriteValueAMD64_OpSignExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSignExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSignExt8to64(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBQSX x) @@ -22069,7 +21805,7 @@ func rewriteValueAMD64_OpSignExt8to64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSlicemask(v *Value, config *Config) bool { +func rewriteValueAMD64_OpSlicemask(v *Value) bool { b := v.Block _ = b // match: (Slicemask <t> x) @@ -22086,9 +21822,7 @@ func rewriteValueAMD64_OpSlicemask(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSqrt(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSqrt(v *Value) bool { // match: (Sqrt x) // cond: // result: (SQRTSD x) @@ -22099,9 +21833,7 @@ func rewriteValueAMD64_OpSqrt(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpStaticCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpStaticCall(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -22116,9 +21848,7 @@ func rewriteValueAMD64_OpStaticCall(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpStore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpStore(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type) // result: (MOVSDstore ptr val mem) @@ -22223,9 +21953,7 @@ func rewriteValueAMD64_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpSub16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSub16(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUBL x y) @@ -22238,9 +21966,7 @@ func rewriteValueAMD64_OpSub16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSub32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSub32(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUBL x y) @@ -22253,9 +21979,7 @@ func rewriteValueAMD64_OpSub32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSub32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSub32F(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBSS x y) @@ -22268,9 +21992,7 @@ func rewriteValueAMD64_OpSub32F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSub64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSub64(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUBQ x y) @@ -22283,9 +22005,7 @@ func rewriteValueAMD64_OpSub64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSub64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSub64F(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBSD x y) @@ -22298,9 +22018,7 @@ func rewriteValueAMD64_OpSub64F(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSub8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpSub8(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUBL x y) @@ -22313,9 +22031,11 @@ func rewriteValueAMD64_OpSub8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpSubPtr(v *Value, config *Config) bool { +func rewriteValueAMD64_OpSubPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (SubPtr x y) // cond: config.PtrSize == 8 // result: (SUBQ x y) @@ -22346,9 +22066,7 @@ func rewriteValueAMD64_OpSubPtr(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpTrunc16to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpTrunc16to8(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -22360,9 +22078,7 @@ func rewriteValueAMD64_OpTrunc16to8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpTrunc32to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpTrunc32to16(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -22374,9 +22090,7 @@ func rewriteValueAMD64_OpTrunc32to16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpTrunc32to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpTrunc32to8(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -22388,9 +22102,7 @@ func rewriteValueAMD64_OpTrunc32to8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpTrunc64to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpTrunc64to16(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: x @@ -22402,9 +22114,7 @@ func rewriteValueAMD64_OpTrunc64to16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpTrunc64to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpTrunc64to32(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: x @@ -22416,9 +22126,7 @@ func rewriteValueAMD64_OpTrunc64to32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpTrunc64to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpTrunc64to8(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: x @@ -22430,9 +22138,7 @@ func rewriteValueAMD64_OpTrunc64to8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpXor16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpXor16(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XORL x y) @@ -22445,9 +22151,7 @@ func rewriteValueAMD64_OpXor16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpXor32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpXor32(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XORL x y) @@ -22460,9 +22164,7 @@ func rewriteValueAMD64_OpXor32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpXor64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpXor64(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XORQ x y) @@ -22475,9 +22177,7 @@ func rewriteValueAMD64_OpXor64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpXor8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpXor8(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XORL x y) @@ -22490,9 +22190,13 @@ func rewriteValueAMD64_OpXor8(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpZero(v *Value, config *Config) bool { +func rewriteValueAMD64_OpZero(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Zero [0] _ mem) // cond: // result: mem @@ -22752,7 +22456,7 @@ func rewriteValueAMD64_OpZero(v *Value, config *Config) bool { v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem) v1.AddArg(destptr) - v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -22790,10 +22494,10 @@ func rewriteValueAMD64_OpZero(v *Value, config *Config) bool { } v.reset(OpAMD64REPSTOSQ) v.AddArg(destptr) - v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0.AuxInt = s / 8 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v1.AuxInt = 0 v.AddArg(v1) v.AddArg(mem) @@ -22801,9 +22505,7 @@ func rewriteValueAMD64_OpZero(v *Value, config *Config) bool { } return false } -func rewriteValueAMD64_OpZeroExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpZeroExt16to32(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVWQZX x) @@ -22814,9 +22516,7 @@ func rewriteValueAMD64_OpZeroExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpZeroExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpZeroExt16to64(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVWQZX x) @@ -22827,9 +22527,7 @@ func rewriteValueAMD64_OpZeroExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpZeroExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpZeroExt32to64(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVLQZX x) @@ -22840,9 +22538,7 @@ func rewriteValueAMD64_OpZeroExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpZeroExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpZeroExt8to16(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBQZX x) @@ -22853,9 +22549,7 @@ func rewriteValueAMD64_OpZeroExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpZeroExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpZeroExt8to32(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBQZX x) @@ -22866,9 +22560,7 @@ func rewriteValueAMD64_OpZeroExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueAMD64_OpZeroExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueAMD64_OpZeroExt8to64(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBQZX x) @@ -22879,7 +22571,11 @@ func rewriteValueAMD64_OpZeroExt8to64(v *Value, config *Config) bool { return true } } -func rewriteBlockAMD64(b *Block, config *Config) bool { +func rewriteBlockAMD64(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { case BlockAMD64EQ: // match: (EQ (TESTL (SHLL (MOVLconst [1]) x) y)) diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go index 83bdde4c17..665eec36c8 100644 --- a/src/cmd/compile/internal/ssa/rewriteARM.go +++ b/src/cmd/compile/internal/ssa/rewriteARM.go @@ -6,726 +6,724 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValueARM(v *Value, config *Config) bool { +func rewriteValueARM(v *Value) bool { switch v.Op { case OpARMADC: - return rewriteValueARM_OpARMADC(v, config) + return rewriteValueARM_OpARMADC(v) case OpARMADCconst: - return rewriteValueARM_OpARMADCconst(v, config) + return rewriteValueARM_OpARMADCconst(v) case OpARMADCshiftLL: - return rewriteValueARM_OpARMADCshiftLL(v, config) + return rewriteValueARM_OpARMADCshiftLL(v) case OpARMADCshiftLLreg: - return rewriteValueARM_OpARMADCshiftLLreg(v, config) + return rewriteValueARM_OpARMADCshiftLLreg(v) case OpARMADCshiftRA: - return rewriteValueARM_OpARMADCshiftRA(v, config) + return rewriteValueARM_OpARMADCshiftRA(v) case OpARMADCshiftRAreg: - return rewriteValueARM_OpARMADCshiftRAreg(v, config) + return rewriteValueARM_OpARMADCshiftRAreg(v) case OpARMADCshiftRL: - return rewriteValueARM_OpARMADCshiftRL(v, config) + return rewriteValueARM_OpARMADCshiftRL(v) case OpARMADCshiftRLreg: - return rewriteValueARM_OpARMADCshiftRLreg(v, config) + return rewriteValueARM_OpARMADCshiftRLreg(v) case OpARMADD: - return rewriteValueARM_OpARMADD(v, config) + return rewriteValueARM_OpARMADD(v) case OpARMADDS: - return rewriteValueARM_OpARMADDS(v, config) + return rewriteValueARM_OpARMADDS(v) case OpARMADDSshiftLL: - return rewriteValueARM_OpARMADDSshiftLL(v, config) + return rewriteValueARM_OpARMADDSshiftLL(v) case OpARMADDSshiftLLreg: - return rewriteValueARM_OpARMADDSshiftLLreg(v, config) + return rewriteValueARM_OpARMADDSshiftLLreg(v) case OpARMADDSshiftRA: - return rewriteValueARM_OpARMADDSshiftRA(v, config) + return rewriteValueARM_OpARMADDSshiftRA(v) case OpARMADDSshiftRAreg: - return rewriteValueARM_OpARMADDSshiftRAreg(v, config) + return rewriteValueARM_OpARMADDSshiftRAreg(v) case OpARMADDSshiftRL: - return rewriteValueARM_OpARMADDSshiftRL(v, config) + return rewriteValueARM_OpARMADDSshiftRL(v) case OpARMADDSshiftRLreg: - return rewriteValueARM_OpARMADDSshiftRLreg(v, config) + return rewriteValueARM_OpARMADDSshiftRLreg(v) case OpARMADDconst: - return rewriteValueARM_OpARMADDconst(v, config) + return rewriteValueARM_OpARMADDconst(v) case OpARMADDshiftLL: - return rewriteValueARM_OpARMADDshiftLL(v, config) + return rewriteValueARM_OpARMADDshiftLL(v) case OpARMADDshiftLLreg: - return rewriteValueARM_OpARMADDshiftLLreg(v, config) + return rewriteValueARM_OpARMADDshiftLLreg(v) case OpARMADDshiftRA: - return rewriteValueARM_OpARMADDshiftRA(v, config) + return rewriteValueARM_OpARMADDshiftRA(v) case OpARMADDshiftRAreg: - return rewriteValueARM_OpARMADDshiftRAreg(v, config) + return rewriteValueARM_OpARMADDshiftRAreg(v) case OpARMADDshiftRL: - return rewriteValueARM_OpARMADDshiftRL(v, config) + return rewriteValueARM_OpARMADDshiftRL(v) case OpARMADDshiftRLreg: - return rewriteValueARM_OpARMADDshiftRLreg(v, config) + return rewriteValueARM_OpARMADDshiftRLreg(v) case OpARMAND: - return rewriteValueARM_OpARMAND(v, config) + return rewriteValueARM_OpARMAND(v) case OpARMANDconst: - return rewriteValueARM_OpARMANDconst(v, config) + return rewriteValueARM_OpARMANDconst(v) case OpARMANDshiftLL: - return rewriteValueARM_OpARMANDshiftLL(v, config) + return rewriteValueARM_OpARMANDshiftLL(v) case OpARMANDshiftLLreg: - return rewriteValueARM_OpARMANDshiftLLreg(v, config) + return rewriteValueARM_OpARMANDshiftLLreg(v) case OpARMANDshiftRA: - return rewriteValueARM_OpARMANDshiftRA(v, config) + return rewriteValueARM_OpARMANDshiftRA(v) case OpARMANDshiftRAreg: - return rewriteValueARM_OpARMANDshiftRAreg(v, config) + return rewriteValueARM_OpARMANDshiftRAreg(v) case OpARMANDshiftRL: - return rewriteValueARM_OpARMANDshiftRL(v, config) + return rewriteValueARM_OpARMANDshiftRL(v) case OpARMANDshiftRLreg: - return rewriteValueARM_OpARMANDshiftRLreg(v, config) + return rewriteValueARM_OpARMANDshiftRLreg(v) case OpARMBIC: - return rewriteValueARM_OpARMBIC(v, config) + return rewriteValueARM_OpARMBIC(v) case OpARMBICconst: - return rewriteValueARM_OpARMBICconst(v, config) + return rewriteValueARM_OpARMBICconst(v) case OpARMBICshiftLL: - return rewriteValueARM_OpARMBICshiftLL(v, config) + return rewriteValueARM_OpARMBICshiftLL(v) case OpARMBICshiftLLreg: - return rewriteValueARM_OpARMBICshiftLLreg(v, config) + return rewriteValueARM_OpARMBICshiftLLreg(v) case OpARMBICshiftRA: - return rewriteValueARM_OpARMBICshiftRA(v, config) + return rewriteValueARM_OpARMBICshiftRA(v) case OpARMBICshiftRAreg: - return rewriteValueARM_OpARMBICshiftRAreg(v, config) + return rewriteValueARM_OpARMBICshiftRAreg(v) case OpARMBICshiftRL: - return rewriteValueARM_OpARMBICshiftRL(v, config) + return rewriteValueARM_OpARMBICshiftRL(v) case OpARMBICshiftRLreg: - return rewriteValueARM_OpARMBICshiftRLreg(v, config) + return rewriteValueARM_OpARMBICshiftRLreg(v) case OpARMCMOVWHSconst: - return rewriteValueARM_OpARMCMOVWHSconst(v, config) + return rewriteValueARM_OpARMCMOVWHSconst(v) case OpARMCMOVWLSconst: - return rewriteValueARM_OpARMCMOVWLSconst(v, config) + return rewriteValueARM_OpARMCMOVWLSconst(v) case OpARMCMP: - return rewriteValueARM_OpARMCMP(v, config) + return rewriteValueARM_OpARMCMP(v) case OpARMCMPD: - return rewriteValueARM_OpARMCMPD(v, config) + return rewriteValueARM_OpARMCMPD(v) case OpARMCMPF: - return rewriteValueARM_OpARMCMPF(v, config) + return rewriteValueARM_OpARMCMPF(v) case OpARMCMPconst: - return rewriteValueARM_OpARMCMPconst(v, config) + return rewriteValueARM_OpARMCMPconst(v) case OpARMCMPshiftLL: - return rewriteValueARM_OpARMCMPshiftLL(v, config) + return rewriteValueARM_OpARMCMPshiftLL(v) case OpARMCMPshiftLLreg: - return rewriteValueARM_OpARMCMPshiftLLreg(v, config) + return rewriteValueARM_OpARMCMPshiftLLreg(v) case OpARMCMPshiftRA: - return rewriteValueARM_OpARMCMPshiftRA(v, config) + return rewriteValueARM_OpARMCMPshiftRA(v) case OpARMCMPshiftRAreg: - return rewriteValueARM_OpARMCMPshiftRAreg(v, config) + return rewriteValueARM_OpARMCMPshiftRAreg(v) case OpARMCMPshiftRL: - return rewriteValueARM_OpARMCMPshiftRL(v, config) + return rewriteValueARM_OpARMCMPshiftRL(v) case OpARMCMPshiftRLreg: - return rewriteValueARM_OpARMCMPshiftRLreg(v, config) + return rewriteValueARM_OpARMCMPshiftRLreg(v) case OpARMEqual: - return rewriteValueARM_OpARMEqual(v, config) + return rewriteValueARM_OpARMEqual(v) case OpARMGreaterEqual: - return rewriteValueARM_OpARMGreaterEqual(v, config) + return rewriteValueARM_OpARMGreaterEqual(v) case OpARMGreaterEqualU: - return rewriteValueARM_OpARMGreaterEqualU(v, config) + return rewriteValueARM_OpARMGreaterEqualU(v) case OpARMGreaterThan: - return rewriteValueARM_OpARMGreaterThan(v, config) + return rewriteValueARM_OpARMGreaterThan(v) case OpARMGreaterThanU: - return rewriteValueARM_OpARMGreaterThanU(v, config) + return rewriteValueARM_OpARMGreaterThanU(v) case OpARMLessEqual: - return rewriteValueARM_OpARMLessEqual(v, config) + return rewriteValueARM_OpARMLessEqual(v) case OpARMLessEqualU: - return rewriteValueARM_OpARMLessEqualU(v, config) + return rewriteValueARM_OpARMLessEqualU(v) case OpARMLessThan: - return rewriteValueARM_OpARMLessThan(v, config) + return rewriteValueARM_OpARMLessThan(v) case OpARMLessThanU: - return rewriteValueARM_OpARMLessThanU(v, config) + return rewriteValueARM_OpARMLessThanU(v) case OpARMMOVBUload: - return rewriteValueARM_OpARMMOVBUload(v, config) + return rewriteValueARM_OpARMMOVBUload(v) case OpARMMOVBUreg: - return rewriteValueARM_OpARMMOVBUreg(v, config) + return rewriteValueARM_OpARMMOVBUreg(v) case OpARMMOVBload: - return rewriteValueARM_OpARMMOVBload(v, config) + return rewriteValueARM_OpARMMOVBload(v) case OpARMMOVBreg: - return rewriteValueARM_OpARMMOVBreg(v, config) + return rewriteValueARM_OpARMMOVBreg(v) case OpARMMOVBstore: - return rewriteValueARM_OpARMMOVBstore(v, config) + return rewriteValueARM_OpARMMOVBstore(v) case OpARMMOVDload: - return rewriteValueARM_OpARMMOVDload(v, config) + return rewriteValueARM_OpARMMOVDload(v) case OpARMMOVDstore: - return rewriteValueARM_OpARMMOVDstore(v, config) + return rewriteValueARM_OpARMMOVDstore(v) case OpARMMOVFload: - return rewriteValueARM_OpARMMOVFload(v, config) + return rewriteValueARM_OpARMMOVFload(v) case OpARMMOVFstore: - return rewriteValueARM_OpARMMOVFstore(v, config) + return rewriteValueARM_OpARMMOVFstore(v) case OpARMMOVHUload: - return rewriteValueARM_OpARMMOVHUload(v, config) + return rewriteValueARM_OpARMMOVHUload(v) case OpARMMOVHUreg: - return rewriteValueARM_OpARMMOVHUreg(v, config) + return rewriteValueARM_OpARMMOVHUreg(v) case OpARMMOVHload: - return rewriteValueARM_OpARMMOVHload(v, config) + return rewriteValueARM_OpARMMOVHload(v) case OpARMMOVHreg: - return rewriteValueARM_OpARMMOVHreg(v, config) + return rewriteValueARM_OpARMMOVHreg(v) case OpARMMOVHstore: - return rewriteValueARM_OpARMMOVHstore(v, config) + return rewriteValueARM_OpARMMOVHstore(v) case OpARMMOVWload: - return rewriteValueARM_OpARMMOVWload(v, config) + return rewriteValueARM_OpARMMOVWload(v) case OpARMMOVWloadidx: - return rewriteValueARM_OpARMMOVWloadidx(v, config) + return rewriteValueARM_OpARMMOVWloadidx(v) case OpARMMOVWloadshiftLL: - return rewriteValueARM_OpARMMOVWloadshiftLL(v, config) + return rewriteValueARM_OpARMMOVWloadshiftLL(v) case OpARMMOVWloadshiftRA: - return rewriteValueARM_OpARMMOVWloadshiftRA(v, config) + return rewriteValueARM_OpARMMOVWloadshiftRA(v) case OpARMMOVWloadshiftRL: - return rewriteValueARM_OpARMMOVWloadshiftRL(v, config) + return rewriteValueARM_OpARMMOVWloadshiftRL(v) case OpARMMOVWreg: - return rewriteValueARM_OpARMMOVWreg(v, config) + return rewriteValueARM_OpARMMOVWreg(v) case OpARMMOVWstore: - return rewriteValueARM_OpARMMOVWstore(v, config) + return rewriteValueARM_OpARMMOVWstore(v) case OpARMMOVWstoreidx: - return rewriteValueARM_OpARMMOVWstoreidx(v, config) + return rewriteValueARM_OpARMMOVWstoreidx(v) case OpARMMOVWstoreshiftLL: - return rewriteValueARM_OpARMMOVWstoreshiftLL(v, config) + return rewriteValueARM_OpARMMOVWstoreshiftLL(v) case OpARMMOVWstoreshiftRA: - return rewriteValueARM_OpARMMOVWstoreshiftRA(v, config) + return rewriteValueARM_OpARMMOVWstoreshiftRA(v) case OpARMMOVWstoreshiftRL: - return rewriteValueARM_OpARMMOVWstoreshiftRL(v, config) + return rewriteValueARM_OpARMMOVWstoreshiftRL(v) case OpARMMUL: - return rewriteValueARM_OpARMMUL(v, config) + return rewriteValueARM_OpARMMUL(v) case OpARMMULA: - return rewriteValueARM_OpARMMULA(v, config) + return rewriteValueARM_OpARMMULA(v) case OpARMMVN: - return rewriteValueARM_OpARMMVN(v, config) + return rewriteValueARM_OpARMMVN(v) case OpARMMVNshiftLL: - return rewriteValueARM_OpARMMVNshiftLL(v, config) + return rewriteValueARM_OpARMMVNshiftLL(v) case OpARMMVNshiftLLreg: - return rewriteValueARM_OpARMMVNshiftLLreg(v, config) + return rewriteValueARM_OpARMMVNshiftLLreg(v) case OpARMMVNshiftRA: - return rewriteValueARM_OpARMMVNshiftRA(v, config) + return rewriteValueARM_OpARMMVNshiftRA(v) case OpARMMVNshiftRAreg: - return rewriteValueARM_OpARMMVNshiftRAreg(v, config) + return rewriteValueARM_OpARMMVNshiftRAreg(v) case OpARMMVNshiftRL: - return rewriteValueARM_OpARMMVNshiftRL(v, config) + return rewriteValueARM_OpARMMVNshiftRL(v) case OpARMMVNshiftRLreg: - return rewriteValueARM_OpARMMVNshiftRLreg(v, config) + return rewriteValueARM_OpARMMVNshiftRLreg(v) case OpARMNotEqual: - return rewriteValueARM_OpARMNotEqual(v, config) + return rewriteValueARM_OpARMNotEqual(v) case OpARMOR: - return rewriteValueARM_OpARMOR(v, config) + return rewriteValueARM_OpARMOR(v) case OpARMORconst: - return rewriteValueARM_OpARMORconst(v, config) + return rewriteValueARM_OpARMORconst(v) case OpARMORshiftLL: - return rewriteValueARM_OpARMORshiftLL(v, config) + return rewriteValueARM_OpARMORshiftLL(v) case OpARMORshiftLLreg: - return rewriteValueARM_OpARMORshiftLLreg(v, config) + return rewriteValueARM_OpARMORshiftLLreg(v) case OpARMORshiftRA: - return rewriteValueARM_OpARMORshiftRA(v, config) + return rewriteValueARM_OpARMORshiftRA(v) case OpARMORshiftRAreg: - return rewriteValueARM_OpARMORshiftRAreg(v, config) + return rewriteValueARM_OpARMORshiftRAreg(v) case OpARMORshiftRL: - return rewriteValueARM_OpARMORshiftRL(v, config) + return rewriteValueARM_OpARMORshiftRL(v) case OpARMORshiftRLreg: - return rewriteValueARM_OpARMORshiftRLreg(v, config) + return rewriteValueARM_OpARMORshiftRLreg(v) case OpARMRSB: - return rewriteValueARM_OpARMRSB(v, config) + return rewriteValueARM_OpARMRSB(v) case OpARMRSBSshiftLL: - return rewriteValueARM_OpARMRSBSshiftLL(v, config) + return rewriteValueARM_OpARMRSBSshiftLL(v) case OpARMRSBSshiftLLreg: - return rewriteValueARM_OpARMRSBSshiftLLreg(v, config) + return rewriteValueARM_OpARMRSBSshiftLLreg(v) case OpARMRSBSshiftRA: - return rewriteValueARM_OpARMRSBSshiftRA(v, config) + return rewriteValueARM_OpARMRSBSshiftRA(v) case OpARMRSBSshiftRAreg: - return rewriteValueARM_OpARMRSBSshiftRAreg(v, config) + return rewriteValueARM_OpARMRSBSshiftRAreg(v) case OpARMRSBSshiftRL: - return rewriteValueARM_OpARMRSBSshiftRL(v, config) + return rewriteValueARM_OpARMRSBSshiftRL(v) case OpARMRSBSshiftRLreg: - return rewriteValueARM_OpARMRSBSshiftRLreg(v, config) + return rewriteValueARM_OpARMRSBSshiftRLreg(v) case OpARMRSBconst: - return rewriteValueARM_OpARMRSBconst(v, config) + return rewriteValueARM_OpARMRSBconst(v) case OpARMRSBshiftLL: - return rewriteValueARM_OpARMRSBshiftLL(v, config) + return rewriteValueARM_OpARMRSBshiftLL(v) case OpARMRSBshiftLLreg: - return rewriteValueARM_OpARMRSBshiftLLreg(v, config) + return rewriteValueARM_OpARMRSBshiftLLreg(v) case OpARMRSBshiftRA: - return rewriteValueARM_OpARMRSBshiftRA(v, config) + return rewriteValueARM_OpARMRSBshiftRA(v) case OpARMRSBshiftRAreg: - return rewriteValueARM_OpARMRSBshiftRAreg(v, config) + return rewriteValueARM_OpARMRSBshiftRAreg(v) case OpARMRSBshiftRL: - return rewriteValueARM_OpARMRSBshiftRL(v, config) + return rewriteValueARM_OpARMRSBshiftRL(v) case OpARMRSBshiftRLreg: - return rewriteValueARM_OpARMRSBshiftRLreg(v, config) + return rewriteValueARM_OpARMRSBshiftRLreg(v) case OpARMRSCconst: - return rewriteValueARM_OpARMRSCconst(v, config) + return rewriteValueARM_OpARMRSCconst(v) case OpARMRSCshiftLL: - return rewriteValueARM_OpARMRSCshiftLL(v, config) + return rewriteValueARM_OpARMRSCshiftLL(v) case OpARMRSCshiftLLreg: - return rewriteValueARM_OpARMRSCshiftLLreg(v, config) + return rewriteValueARM_OpARMRSCshiftLLreg(v) case OpARMRSCshiftRA: - return rewriteValueARM_OpARMRSCshiftRA(v, config) + return rewriteValueARM_OpARMRSCshiftRA(v) case OpARMRSCshiftRAreg: - return rewriteValueARM_OpARMRSCshiftRAreg(v, config) + return rewriteValueARM_OpARMRSCshiftRAreg(v) case OpARMRSCshiftRL: - return rewriteValueARM_OpARMRSCshiftRL(v, config) + return rewriteValueARM_OpARMRSCshiftRL(v) case OpARMRSCshiftRLreg: - return rewriteValueARM_OpARMRSCshiftRLreg(v, config) + return rewriteValueARM_OpARMRSCshiftRLreg(v) case OpARMSBC: - return rewriteValueARM_OpARMSBC(v, config) + return rewriteValueARM_OpARMSBC(v) case OpARMSBCconst: - return rewriteValueARM_OpARMSBCconst(v, config) + return rewriteValueARM_OpARMSBCconst(v) case OpARMSBCshiftLL: - return rewriteValueARM_OpARMSBCshiftLL(v, config) + return rewriteValueARM_OpARMSBCshiftLL(v) case OpARMSBCshiftLLreg: - return rewriteValueARM_OpARMSBCshiftLLreg(v, config) + return rewriteValueARM_OpARMSBCshiftLLreg(v) case OpARMSBCshiftRA: - return rewriteValueARM_OpARMSBCshiftRA(v, config) + return rewriteValueARM_OpARMSBCshiftRA(v) case OpARMSBCshiftRAreg: - return rewriteValueARM_OpARMSBCshiftRAreg(v, config) + return rewriteValueARM_OpARMSBCshiftRAreg(v) case OpARMSBCshiftRL: - return rewriteValueARM_OpARMSBCshiftRL(v, config) + return rewriteValueARM_OpARMSBCshiftRL(v) case OpARMSBCshiftRLreg: - return rewriteValueARM_OpARMSBCshiftRLreg(v, config) + return rewriteValueARM_OpARMSBCshiftRLreg(v) case OpARMSLL: - return rewriteValueARM_OpARMSLL(v, config) + return rewriteValueARM_OpARMSLL(v) case OpARMSLLconst: - return rewriteValueARM_OpARMSLLconst(v, config) + return rewriteValueARM_OpARMSLLconst(v) case OpARMSRA: - return rewriteValueARM_OpARMSRA(v, config) + return rewriteValueARM_OpARMSRA(v) case OpARMSRAcond: - return rewriteValueARM_OpARMSRAcond(v, config) + return rewriteValueARM_OpARMSRAcond(v) case OpARMSRAconst: - return rewriteValueARM_OpARMSRAconst(v, config) + return rewriteValueARM_OpARMSRAconst(v) case OpARMSRL: - return rewriteValueARM_OpARMSRL(v, config) + return rewriteValueARM_OpARMSRL(v) case OpARMSRLconst: - return rewriteValueARM_OpARMSRLconst(v, config) + return rewriteValueARM_OpARMSRLconst(v) case OpARMSUB: - return rewriteValueARM_OpARMSUB(v, config) + return rewriteValueARM_OpARMSUB(v) case OpARMSUBS: - return rewriteValueARM_OpARMSUBS(v, config) + return rewriteValueARM_OpARMSUBS(v) case OpARMSUBSshiftLL: - return rewriteValueARM_OpARMSUBSshiftLL(v, config) + return rewriteValueARM_OpARMSUBSshiftLL(v) case OpARMSUBSshiftLLreg: - return rewriteValueARM_OpARMSUBSshiftLLreg(v, config) + return rewriteValueARM_OpARMSUBSshiftLLreg(v) case OpARMSUBSshiftRA: - return rewriteValueARM_OpARMSUBSshiftRA(v, config) + return rewriteValueARM_OpARMSUBSshiftRA(v) case OpARMSUBSshiftRAreg: - return rewriteValueARM_OpARMSUBSshiftRAreg(v, config) + return rewriteValueARM_OpARMSUBSshiftRAreg(v) case OpARMSUBSshiftRL: - return rewriteValueARM_OpARMSUBSshiftRL(v, config) + return rewriteValueARM_OpARMSUBSshiftRL(v) case OpARMSUBSshiftRLreg: - return rewriteValueARM_OpARMSUBSshiftRLreg(v, config) + return rewriteValueARM_OpARMSUBSshiftRLreg(v) case OpARMSUBconst: - return rewriteValueARM_OpARMSUBconst(v, config) + return rewriteValueARM_OpARMSUBconst(v) case OpARMSUBshiftLL: - return rewriteValueARM_OpARMSUBshiftLL(v, config) + return rewriteValueARM_OpARMSUBshiftLL(v) case OpARMSUBshiftLLreg: - return rewriteValueARM_OpARMSUBshiftLLreg(v, config) + return rewriteValueARM_OpARMSUBshiftLLreg(v) case OpARMSUBshiftRA: - return rewriteValueARM_OpARMSUBshiftRA(v, config) + return rewriteValueARM_OpARMSUBshiftRA(v) case OpARMSUBshiftRAreg: - return rewriteValueARM_OpARMSUBshiftRAreg(v, config) + return rewriteValueARM_OpARMSUBshiftRAreg(v) case OpARMSUBshiftRL: - return rewriteValueARM_OpARMSUBshiftRL(v, config) + return rewriteValueARM_OpARMSUBshiftRL(v) case OpARMSUBshiftRLreg: - return rewriteValueARM_OpARMSUBshiftRLreg(v, config) + return rewriteValueARM_OpARMSUBshiftRLreg(v) case OpARMXOR: - return rewriteValueARM_OpARMXOR(v, config) + return rewriteValueARM_OpARMXOR(v) case OpARMXORconst: - return rewriteValueARM_OpARMXORconst(v, config) + return rewriteValueARM_OpARMXORconst(v) case OpARMXORshiftLL: - return rewriteValueARM_OpARMXORshiftLL(v, config) + return rewriteValueARM_OpARMXORshiftLL(v) case OpARMXORshiftLLreg: - return rewriteValueARM_OpARMXORshiftLLreg(v, config) + return rewriteValueARM_OpARMXORshiftLLreg(v) case OpARMXORshiftRA: - return rewriteValueARM_OpARMXORshiftRA(v, config) + return rewriteValueARM_OpARMXORshiftRA(v) case OpARMXORshiftRAreg: - return rewriteValueARM_OpARMXORshiftRAreg(v, config) + return rewriteValueARM_OpARMXORshiftRAreg(v) case OpARMXORshiftRL: - return rewriteValueARM_OpARMXORshiftRL(v, config) + return rewriteValueARM_OpARMXORshiftRL(v) case OpARMXORshiftRLreg: - return rewriteValueARM_OpARMXORshiftRLreg(v, config) + return rewriteValueARM_OpARMXORshiftRLreg(v) case OpARMXORshiftRR: - return rewriteValueARM_OpARMXORshiftRR(v, config) + return rewriteValueARM_OpARMXORshiftRR(v) case OpAdd16: - return rewriteValueARM_OpAdd16(v, config) + return rewriteValueARM_OpAdd16(v) case OpAdd32: - return rewriteValueARM_OpAdd32(v, config) + return rewriteValueARM_OpAdd32(v) case OpAdd32F: - return rewriteValueARM_OpAdd32F(v, config) + return rewriteValueARM_OpAdd32F(v) case OpAdd32carry: - return rewriteValueARM_OpAdd32carry(v, config) + return rewriteValueARM_OpAdd32carry(v) case OpAdd32withcarry: - return rewriteValueARM_OpAdd32withcarry(v, config) + return rewriteValueARM_OpAdd32withcarry(v) case OpAdd64F: - return rewriteValueARM_OpAdd64F(v, config) + return rewriteValueARM_OpAdd64F(v) case OpAdd8: - return rewriteValueARM_OpAdd8(v, config) + return rewriteValueARM_OpAdd8(v) case OpAddPtr: - return rewriteValueARM_OpAddPtr(v, config) + return rewriteValueARM_OpAddPtr(v) case OpAddr: - return rewriteValueARM_OpAddr(v, config) + return rewriteValueARM_OpAddr(v) case OpAnd16: - return rewriteValueARM_OpAnd16(v, config) + return rewriteValueARM_OpAnd16(v) case OpAnd32: - return rewriteValueARM_OpAnd32(v, config) + return rewriteValueARM_OpAnd32(v) case OpAnd8: - return rewriteValueARM_OpAnd8(v, config) + return rewriteValueARM_OpAnd8(v) case OpAndB: - return rewriteValueARM_OpAndB(v, config) + return rewriteValueARM_OpAndB(v) case OpAvg32u: - return rewriteValueARM_OpAvg32u(v, config) + return rewriteValueARM_OpAvg32u(v) case OpBitLen32: - return rewriteValueARM_OpBitLen32(v, config) + return rewriteValueARM_OpBitLen32(v) case OpBswap32: - return rewriteValueARM_OpBswap32(v, config) + return rewriteValueARM_OpBswap32(v) case OpClosureCall: - return rewriteValueARM_OpClosureCall(v, config) + return rewriteValueARM_OpClosureCall(v) case OpCom16: - return rewriteValueARM_OpCom16(v, config) + return rewriteValueARM_OpCom16(v) case OpCom32: - return rewriteValueARM_OpCom32(v, config) + return rewriteValueARM_OpCom32(v) case OpCom8: - return rewriteValueARM_OpCom8(v, config) + return rewriteValueARM_OpCom8(v) case OpConst16: - return rewriteValueARM_OpConst16(v, config) + return rewriteValueARM_OpConst16(v) case OpConst32: - return rewriteValueARM_OpConst32(v, config) + return rewriteValueARM_OpConst32(v) case OpConst32F: - return rewriteValueARM_OpConst32F(v, config) + return rewriteValueARM_OpConst32F(v) case OpConst64F: - return rewriteValueARM_OpConst64F(v, config) + return rewriteValueARM_OpConst64F(v) case OpConst8: - return rewriteValueARM_OpConst8(v, config) + return rewriteValueARM_OpConst8(v) case OpConstBool: - return rewriteValueARM_OpConstBool(v, config) + return rewriteValueARM_OpConstBool(v) case OpConstNil: - return rewriteValueARM_OpConstNil(v, config) + return rewriteValueARM_OpConstNil(v) case OpConvert: - return rewriteValueARM_OpConvert(v, config) + return rewriteValueARM_OpConvert(v) case OpCtz32: - return rewriteValueARM_OpCtz32(v, config) + return rewriteValueARM_OpCtz32(v) case OpCvt32Fto32: - return rewriteValueARM_OpCvt32Fto32(v, config) + return rewriteValueARM_OpCvt32Fto32(v) case OpCvt32Fto32U: - return rewriteValueARM_OpCvt32Fto32U(v, config) + return rewriteValueARM_OpCvt32Fto32U(v) case OpCvt32Fto64F: - return rewriteValueARM_OpCvt32Fto64F(v, config) + return rewriteValueARM_OpCvt32Fto64F(v) case OpCvt32Uto32F: - return rewriteValueARM_OpCvt32Uto32F(v, config) + return rewriteValueARM_OpCvt32Uto32F(v) case OpCvt32Uto64F: - return rewriteValueARM_OpCvt32Uto64F(v, config) + return rewriteValueARM_OpCvt32Uto64F(v) case OpCvt32to32F: - return rewriteValueARM_OpCvt32to32F(v, config) + return rewriteValueARM_OpCvt32to32F(v) case OpCvt32to64F: - return rewriteValueARM_OpCvt32to64F(v, config) + return rewriteValueARM_OpCvt32to64F(v) case OpCvt64Fto32: - return rewriteValueARM_OpCvt64Fto32(v, config) + return rewriteValueARM_OpCvt64Fto32(v) case OpCvt64Fto32F: - return rewriteValueARM_OpCvt64Fto32F(v, config) + return rewriteValueARM_OpCvt64Fto32F(v) case OpCvt64Fto32U: - return rewriteValueARM_OpCvt64Fto32U(v, config) + return rewriteValueARM_OpCvt64Fto32U(v) case OpDiv16: - return rewriteValueARM_OpDiv16(v, config) + return rewriteValueARM_OpDiv16(v) case OpDiv16u: - return rewriteValueARM_OpDiv16u(v, config) + return rewriteValueARM_OpDiv16u(v) case OpDiv32: - return rewriteValueARM_OpDiv32(v, config) + return rewriteValueARM_OpDiv32(v) case OpDiv32F: - return rewriteValueARM_OpDiv32F(v, config) + return rewriteValueARM_OpDiv32F(v) case OpDiv32u: - return rewriteValueARM_OpDiv32u(v, config) + return rewriteValueARM_OpDiv32u(v) case OpDiv64F: - return rewriteValueARM_OpDiv64F(v, config) + return rewriteValueARM_OpDiv64F(v) case OpDiv8: - return rewriteValueARM_OpDiv8(v, config) + return rewriteValueARM_OpDiv8(v) case OpDiv8u: - return rewriteValueARM_OpDiv8u(v, config) + return rewriteValueARM_OpDiv8u(v) case OpEq16: - return rewriteValueARM_OpEq16(v, config) + return rewriteValueARM_OpEq16(v) case OpEq32: - return rewriteValueARM_OpEq32(v, config) + return rewriteValueARM_OpEq32(v) case OpEq32F: - return rewriteValueARM_OpEq32F(v, config) + return rewriteValueARM_OpEq32F(v) case OpEq64F: - return rewriteValueARM_OpEq64F(v, config) + return rewriteValueARM_OpEq64F(v) case OpEq8: - return rewriteValueARM_OpEq8(v, config) + return rewriteValueARM_OpEq8(v) case OpEqB: - return rewriteValueARM_OpEqB(v, config) + return rewriteValueARM_OpEqB(v) case OpEqPtr: - return rewriteValueARM_OpEqPtr(v, config) + return rewriteValueARM_OpEqPtr(v) case OpGeq16: - return rewriteValueARM_OpGeq16(v, config) + return rewriteValueARM_OpGeq16(v) case OpGeq16U: - return rewriteValueARM_OpGeq16U(v, config) + return rewriteValueARM_OpGeq16U(v) case OpGeq32: - return rewriteValueARM_OpGeq32(v, config) + return rewriteValueARM_OpGeq32(v) case OpGeq32F: - return rewriteValueARM_OpGeq32F(v, config) + return rewriteValueARM_OpGeq32F(v) case OpGeq32U: - return rewriteValueARM_OpGeq32U(v, config) + return rewriteValueARM_OpGeq32U(v) case OpGeq64F: - return rewriteValueARM_OpGeq64F(v, config) + return rewriteValueARM_OpGeq64F(v) case OpGeq8: - return rewriteValueARM_OpGeq8(v, config) + return rewriteValueARM_OpGeq8(v) case OpGeq8U: - return rewriteValueARM_OpGeq8U(v, config) + return rewriteValueARM_OpGeq8U(v) case OpGetClosurePtr: - return rewriteValueARM_OpGetClosurePtr(v, config) + return rewriteValueARM_OpGetClosurePtr(v) case OpGreater16: - return rewriteValueARM_OpGreater16(v, config) + return rewriteValueARM_OpGreater16(v) case OpGreater16U: - return rewriteValueARM_OpGreater16U(v, config) + return rewriteValueARM_OpGreater16U(v) case OpGreater32: - return rewriteValueARM_OpGreater32(v, config) + return rewriteValueARM_OpGreater32(v) case OpGreater32F: - return rewriteValueARM_OpGreater32F(v, config) + return rewriteValueARM_OpGreater32F(v) case OpGreater32U: - return rewriteValueARM_OpGreater32U(v, config) + return rewriteValueARM_OpGreater32U(v) case OpGreater64F: - return rewriteValueARM_OpGreater64F(v, config) + return rewriteValueARM_OpGreater64F(v) case OpGreater8: - return rewriteValueARM_OpGreater8(v, config) + return rewriteValueARM_OpGreater8(v) case OpGreater8U: - return rewriteValueARM_OpGreater8U(v, config) + return rewriteValueARM_OpGreater8U(v) case OpHmul32: - return rewriteValueARM_OpHmul32(v, config) + return rewriteValueARM_OpHmul32(v) case OpHmul32u: - return rewriteValueARM_OpHmul32u(v, config) + return rewriteValueARM_OpHmul32u(v) case OpInterCall: - return rewriteValueARM_OpInterCall(v, config) + return rewriteValueARM_OpInterCall(v) case OpIsInBounds: - return rewriteValueARM_OpIsInBounds(v, config) + return rewriteValueARM_OpIsInBounds(v) case OpIsNonNil: - return rewriteValueARM_OpIsNonNil(v, config) + return rewriteValueARM_OpIsNonNil(v) case OpIsSliceInBounds: - return rewriteValueARM_OpIsSliceInBounds(v, config) + return rewriteValueARM_OpIsSliceInBounds(v) case OpLeq16: - return rewriteValueARM_OpLeq16(v, config) + return rewriteValueARM_OpLeq16(v) case OpLeq16U: - return rewriteValueARM_OpLeq16U(v, config) + return rewriteValueARM_OpLeq16U(v) case OpLeq32: - return rewriteValueARM_OpLeq32(v, config) + return rewriteValueARM_OpLeq32(v) case OpLeq32F: - return rewriteValueARM_OpLeq32F(v, config) + return rewriteValueARM_OpLeq32F(v) case OpLeq32U: - return rewriteValueARM_OpLeq32U(v, config) + return rewriteValueARM_OpLeq32U(v) case OpLeq64F: - return rewriteValueARM_OpLeq64F(v, config) + return rewriteValueARM_OpLeq64F(v) case OpLeq8: - return rewriteValueARM_OpLeq8(v, config) + return rewriteValueARM_OpLeq8(v) case OpLeq8U: - return rewriteValueARM_OpLeq8U(v, config) + return rewriteValueARM_OpLeq8U(v) case OpLess16: - return rewriteValueARM_OpLess16(v, config) + return rewriteValueARM_OpLess16(v) case OpLess16U: - return rewriteValueARM_OpLess16U(v, config) + return rewriteValueARM_OpLess16U(v) case OpLess32: - return rewriteValueARM_OpLess32(v, config) + return rewriteValueARM_OpLess32(v) case OpLess32F: - return rewriteValueARM_OpLess32F(v, config) + return rewriteValueARM_OpLess32F(v) case OpLess32U: - return rewriteValueARM_OpLess32U(v, config) + return rewriteValueARM_OpLess32U(v) case OpLess64F: - return rewriteValueARM_OpLess64F(v, config) + return rewriteValueARM_OpLess64F(v) case OpLess8: - return rewriteValueARM_OpLess8(v, config) + return rewriteValueARM_OpLess8(v) case OpLess8U: - return rewriteValueARM_OpLess8U(v, config) + return rewriteValueARM_OpLess8U(v) case OpLoad: - return rewriteValueARM_OpLoad(v, config) + return rewriteValueARM_OpLoad(v) case OpLsh16x16: - return rewriteValueARM_OpLsh16x16(v, config) + return rewriteValueARM_OpLsh16x16(v) case OpLsh16x32: - return rewriteValueARM_OpLsh16x32(v, config) + return rewriteValueARM_OpLsh16x32(v) case OpLsh16x64: - return rewriteValueARM_OpLsh16x64(v, config) + return rewriteValueARM_OpLsh16x64(v) case OpLsh16x8: - return rewriteValueARM_OpLsh16x8(v, config) + return rewriteValueARM_OpLsh16x8(v) case OpLsh32x16: - return rewriteValueARM_OpLsh32x16(v, config) + return rewriteValueARM_OpLsh32x16(v) case OpLsh32x32: - return rewriteValueARM_OpLsh32x32(v, config) + return rewriteValueARM_OpLsh32x32(v) case OpLsh32x64: - return rewriteValueARM_OpLsh32x64(v, config) + return rewriteValueARM_OpLsh32x64(v) case OpLsh32x8: - return rewriteValueARM_OpLsh32x8(v, config) + return rewriteValueARM_OpLsh32x8(v) case OpLsh8x16: - return rewriteValueARM_OpLsh8x16(v, config) + return rewriteValueARM_OpLsh8x16(v) case OpLsh8x32: - return rewriteValueARM_OpLsh8x32(v, config) + return rewriteValueARM_OpLsh8x32(v) case OpLsh8x64: - return rewriteValueARM_OpLsh8x64(v, config) + return rewriteValueARM_OpLsh8x64(v) case OpLsh8x8: - return rewriteValueARM_OpLsh8x8(v, config) + return rewriteValueARM_OpLsh8x8(v) case OpMod16: - return rewriteValueARM_OpMod16(v, config) + return rewriteValueARM_OpMod16(v) case OpMod16u: - return rewriteValueARM_OpMod16u(v, config) + return rewriteValueARM_OpMod16u(v) case OpMod32: - return rewriteValueARM_OpMod32(v, config) + return rewriteValueARM_OpMod32(v) case OpMod32u: - return rewriteValueARM_OpMod32u(v, config) + return rewriteValueARM_OpMod32u(v) case OpMod8: - return rewriteValueARM_OpMod8(v, config) + return rewriteValueARM_OpMod8(v) case OpMod8u: - return rewriteValueARM_OpMod8u(v, config) + return rewriteValueARM_OpMod8u(v) case OpMove: - return rewriteValueARM_OpMove(v, config) + return rewriteValueARM_OpMove(v) case OpMul16: - return rewriteValueARM_OpMul16(v, config) + return rewriteValueARM_OpMul16(v) case OpMul32: - return rewriteValueARM_OpMul32(v, config) + return rewriteValueARM_OpMul32(v) case OpMul32F: - return rewriteValueARM_OpMul32F(v, config) + return rewriteValueARM_OpMul32F(v) case OpMul32uhilo: - return rewriteValueARM_OpMul32uhilo(v, config) + return rewriteValueARM_OpMul32uhilo(v) case OpMul64F: - return rewriteValueARM_OpMul64F(v, config) + return rewriteValueARM_OpMul64F(v) case OpMul8: - return rewriteValueARM_OpMul8(v, config) + return rewriteValueARM_OpMul8(v) case OpNeg16: - return rewriteValueARM_OpNeg16(v, config) + return rewriteValueARM_OpNeg16(v) case OpNeg32: - return rewriteValueARM_OpNeg32(v, config) + return rewriteValueARM_OpNeg32(v) case OpNeg32F: - return rewriteValueARM_OpNeg32F(v, config) + return rewriteValueARM_OpNeg32F(v) case OpNeg64F: - return rewriteValueARM_OpNeg64F(v, config) + return rewriteValueARM_OpNeg64F(v) case OpNeg8: - return rewriteValueARM_OpNeg8(v, config) + return rewriteValueARM_OpNeg8(v) case OpNeq16: - return rewriteValueARM_OpNeq16(v, config) + return rewriteValueARM_OpNeq16(v) case OpNeq32: - return rewriteValueARM_OpNeq32(v, config) + return rewriteValueARM_OpNeq32(v) case OpNeq32F: - return rewriteValueARM_OpNeq32F(v, config) + return rewriteValueARM_OpNeq32F(v) case OpNeq64F: - return rewriteValueARM_OpNeq64F(v, config) + return rewriteValueARM_OpNeq64F(v) case OpNeq8: - return rewriteValueARM_OpNeq8(v, config) + return rewriteValueARM_OpNeq8(v) case OpNeqB: - return rewriteValueARM_OpNeqB(v, config) + return rewriteValueARM_OpNeqB(v) case OpNeqPtr: - return rewriteValueARM_OpNeqPtr(v, config) + return rewriteValueARM_OpNeqPtr(v) case OpNilCheck: - return rewriteValueARM_OpNilCheck(v, config) + return rewriteValueARM_OpNilCheck(v) case OpNot: - return rewriteValueARM_OpNot(v, config) + return rewriteValueARM_OpNot(v) case OpOffPtr: - return rewriteValueARM_OpOffPtr(v, config) + return rewriteValueARM_OpOffPtr(v) case OpOr16: - return rewriteValueARM_OpOr16(v, config) + return rewriteValueARM_OpOr16(v) case OpOr32: - return rewriteValueARM_OpOr32(v, config) + return rewriteValueARM_OpOr32(v) case OpOr8: - return rewriteValueARM_OpOr8(v, config) + return rewriteValueARM_OpOr8(v) case OpOrB: - return rewriteValueARM_OpOrB(v, config) + return rewriteValueARM_OpOrB(v) case OpRound32F: - return rewriteValueARM_OpRound32F(v, config) + return rewriteValueARM_OpRound32F(v) case OpRound64F: - return rewriteValueARM_OpRound64F(v, config) + return rewriteValueARM_OpRound64F(v) case OpRsh16Ux16: - return rewriteValueARM_OpRsh16Ux16(v, config) + return rewriteValueARM_OpRsh16Ux16(v) case OpRsh16Ux32: - return rewriteValueARM_OpRsh16Ux32(v, config) + return rewriteValueARM_OpRsh16Ux32(v) case OpRsh16Ux64: - return rewriteValueARM_OpRsh16Ux64(v, config) + return rewriteValueARM_OpRsh16Ux64(v) case OpRsh16Ux8: - return rewriteValueARM_OpRsh16Ux8(v, config) + return rewriteValueARM_OpRsh16Ux8(v) case OpRsh16x16: - return rewriteValueARM_OpRsh16x16(v, config) + return rewriteValueARM_OpRsh16x16(v) case OpRsh16x32: - return rewriteValueARM_OpRsh16x32(v, config) + return rewriteValueARM_OpRsh16x32(v) case OpRsh16x64: - return rewriteValueARM_OpRsh16x64(v, config) + return rewriteValueARM_OpRsh16x64(v) case OpRsh16x8: - return rewriteValueARM_OpRsh16x8(v, config) + return rewriteValueARM_OpRsh16x8(v) case OpRsh32Ux16: - return rewriteValueARM_OpRsh32Ux16(v, config) + return rewriteValueARM_OpRsh32Ux16(v) case OpRsh32Ux32: - return rewriteValueARM_OpRsh32Ux32(v, config) + return rewriteValueARM_OpRsh32Ux32(v) case OpRsh32Ux64: - return rewriteValueARM_OpRsh32Ux64(v, config) + return rewriteValueARM_OpRsh32Ux64(v) case OpRsh32Ux8: - return rewriteValueARM_OpRsh32Ux8(v, config) + return rewriteValueARM_OpRsh32Ux8(v) case OpRsh32x16: - return rewriteValueARM_OpRsh32x16(v, config) + return rewriteValueARM_OpRsh32x16(v) case OpRsh32x32: - return rewriteValueARM_OpRsh32x32(v, config) + return rewriteValueARM_OpRsh32x32(v) case OpRsh32x64: - return rewriteValueARM_OpRsh32x64(v, config) + return rewriteValueARM_OpRsh32x64(v) case OpRsh32x8: - return rewriteValueARM_OpRsh32x8(v, config) + return rewriteValueARM_OpRsh32x8(v) case OpRsh8Ux16: - return rewriteValueARM_OpRsh8Ux16(v, config) + return rewriteValueARM_OpRsh8Ux16(v) case OpRsh8Ux32: - return rewriteValueARM_OpRsh8Ux32(v, config) + return rewriteValueARM_OpRsh8Ux32(v) case OpRsh8Ux64: - return rewriteValueARM_OpRsh8Ux64(v, config) + return rewriteValueARM_OpRsh8Ux64(v) case OpRsh8Ux8: - return rewriteValueARM_OpRsh8Ux8(v, config) + return rewriteValueARM_OpRsh8Ux8(v) case OpRsh8x16: - return rewriteValueARM_OpRsh8x16(v, config) + return rewriteValueARM_OpRsh8x16(v) case OpRsh8x32: - return rewriteValueARM_OpRsh8x32(v, config) + return rewriteValueARM_OpRsh8x32(v) case OpRsh8x64: - return rewriteValueARM_OpRsh8x64(v, config) + return rewriteValueARM_OpRsh8x64(v) case OpRsh8x8: - return rewriteValueARM_OpRsh8x8(v, config) + return rewriteValueARM_OpRsh8x8(v) case OpSelect0: - return rewriteValueARM_OpSelect0(v, config) + return rewriteValueARM_OpSelect0(v) case OpSelect1: - return rewriteValueARM_OpSelect1(v, config) + return rewriteValueARM_OpSelect1(v) case OpSignExt16to32: - return rewriteValueARM_OpSignExt16to32(v, config) + return rewriteValueARM_OpSignExt16to32(v) case OpSignExt8to16: - return rewriteValueARM_OpSignExt8to16(v, config) + return rewriteValueARM_OpSignExt8to16(v) case OpSignExt8to32: - return rewriteValueARM_OpSignExt8to32(v, config) + return rewriteValueARM_OpSignExt8to32(v) case OpSignmask: - return rewriteValueARM_OpSignmask(v, config) + return rewriteValueARM_OpSignmask(v) case OpSlicemask: - return rewriteValueARM_OpSlicemask(v, config) + return rewriteValueARM_OpSlicemask(v) case OpSqrt: - return rewriteValueARM_OpSqrt(v, config) + return rewriteValueARM_OpSqrt(v) case OpStaticCall: - return rewriteValueARM_OpStaticCall(v, config) + return rewriteValueARM_OpStaticCall(v) case OpStore: - return rewriteValueARM_OpStore(v, config) + return rewriteValueARM_OpStore(v) case OpSub16: - return rewriteValueARM_OpSub16(v, config) + return rewriteValueARM_OpSub16(v) case OpSub32: - return rewriteValueARM_OpSub32(v, config) + return rewriteValueARM_OpSub32(v) case OpSub32F: - return rewriteValueARM_OpSub32F(v, config) + return rewriteValueARM_OpSub32F(v) case OpSub32carry: - return rewriteValueARM_OpSub32carry(v, config) + return rewriteValueARM_OpSub32carry(v) case OpSub32withcarry: - return rewriteValueARM_OpSub32withcarry(v, config) + return rewriteValueARM_OpSub32withcarry(v) case OpSub64F: - return rewriteValueARM_OpSub64F(v, config) + return rewriteValueARM_OpSub64F(v) case OpSub8: - return rewriteValueARM_OpSub8(v, config) + return rewriteValueARM_OpSub8(v) case OpSubPtr: - return rewriteValueARM_OpSubPtr(v, config) + return rewriteValueARM_OpSubPtr(v) case OpTrunc16to8: - return rewriteValueARM_OpTrunc16to8(v, config) + return rewriteValueARM_OpTrunc16to8(v) case OpTrunc32to16: - return rewriteValueARM_OpTrunc32to16(v, config) + return rewriteValueARM_OpTrunc32to16(v) case OpTrunc32to8: - return rewriteValueARM_OpTrunc32to8(v, config) + return rewriteValueARM_OpTrunc32to8(v) case OpXor16: - return rewriteValueARM_OpXor16(v, config) + return rewriteValueARM_OpXor16(v) case OpXor32: - return rewriteValueARM_OpXor32(v, config) + return rewriteValueARM_OpXor32(v) case OpXor8: - return rewriteValueARM_OpXor8(v, config) + return rewriteValueARM_OpXor8(v) case OpZero: - return rewriteValueARM_OpZero(v, config) + return rewriteValueARM_OpZero(v) case OpZeroExt16to32: - return rewriteValueARM_OpZeroExt16to32(v, config) + return rewriteValueARM_OpZeroExt16to32(v) case OpZeroExt8to16: - return rewriteValueARM_OpZeroExt8to16(v, config) + return rewriteValueARM_OpZeroExt8to16(v) case OpZeroExt8to32: - return rewriteValueARM_OpZeroExt8to32(v, config) + return rewriteValueARM_OpZeroExt8to32(v) case OpZeromask: - return rewriteValueARM_OpZeromask(v, config) + return rewriteValueARM_OpZeromask(v) } return false } -func rewriteValueARM_OpARMADC(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMADC(v *Value) bool { // match: (ADC (MOVWconst [c]) x flags) // cond: // result: (ADCconst [c] x flags) @@ -990,9 +988,7 @@ func rewriteValueARM_OpARMADC(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADCconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMADCconst(v *Value) bool { // match: (ADCconst [c] (ADDconst [d] x) flags) // cond: // result: (ADCconst [int64(int32(c+d))] x flags) @@ -1031,7 +1027,7 @@ func rewriteValueARM_OpARMADCconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADCshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADCshiftLL(v *Value) bool { b := v.Block _ = b // match: (ADCshiftLL (MOVWconst [c]) x [d] flags) @@ -1075,7 +1071,7 @@ func rewriteValueARM_OpARMADCshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADCshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADCshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (ADCshiftLLreg (MOVWconst [c]) x y flags) @@ -1120,7 +1116,7 @@ func rewriteValueARM_OpARMADCshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADCshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADCshiftRA(v *Value) bool { b := v.Block _ = b // match: (ADCshiftRA (MOVWconst [c]) x [d] flags) @@ -1164,7 +1160,7 @@ func rewriteValueARM_OpARMADCshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADCshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADCshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (ADCshiftRAreg (MOVWconst [c]) x y flags) @@ -1209,7 +1205,7 @@ func rewriteValueARM_OpARMADCshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADCshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADCshiftRL(v *Value) bool { b := v.Block _ = b // match: (ADCshiftRL (MOVWconst [c]) x [d] flags) @@ -1253,7 +1249,7 @@ func rewriteValueARM_OpARMADCshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADCshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADCshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (ADCshiftRLreg (MOVWconst [c]) x y flags) @@ -1298,7 +1294,7 @@ func rewriteValueARM_OpARMADCshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADD(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADD(v *Value) bool { b := v.Block _ = b // match: (ADD (MOVWconst [c]) x) @@ -1632,9 +1628,7 @@ func rewriteValueARM_OpARMADD(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDS(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMADDS(v *Value) bool { // match: (ADDS (MOVWconst [c]) x) // cond: // result: (ADDSconst [c] x) @@ -1871,7 +1865,7 @@ func rewriteValueARM_OpARMADDS(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDSshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDSshiftLL(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftLL (MOVWconst [c]) x [d]) @@ -1911,7 +1905,7 @@ func rewriteValueARM_OpARMADDSshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDSshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDSshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftLLreg (MOVWconst [c]) x y) @@ -1952,7 +1946,7 @@ func rewriteValueARM_OpARMADDSshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDSshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDSshiftRA(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftRA (MOVWconst [c]) x [d]) @@ -1992,7 +1986,7 @@ func rewriteValueARM_OpARMADDSshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDSshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDSshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftRAreg (MOVWconst [c]) x y) @@ -2033,7 +2027,7 @@ func rewriteValueARM_OpARMADDSshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDSshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDSshiftRL(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftRL (MOVWconst [c]) x [d]) @@ -2073,7 +2067,7 @@ func rewriteValueARM_OpARMADDSshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDSshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDSshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftRLreg (MOVWconst [c]) x y) @@ -2114,9 +2108,7 @@ func rewriteValueARM_OpARMADDSshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMADDconst(v *Value) bool { // match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr)) // cond: // result: (MOVWaddr [off1+off2] {sym} ptr) @@ -2212,7 +2204,7 @@ func rewriteValueARM_OpARMADDconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDshiftLL(v *Value) bool { b := v.Block _ = b // match: (ADDshiftLL (MOVWconst [c]) x [d]) @@ -2273,7 +2265,7 @@ func rewriteValueARM_OpARMADDshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (ADDshiftLLreg (MOVWconst [c]) x y) @@ -2314,7 +2306,7 @@ func rewriteValueARM_OpARMADDshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDshiftRA(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRA (MOVWconst [c]) x [d]) @@ -2354,7 +2346,7 @@ func rewriteValueARM_OpARMADDshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRAreg (MOVWconst [c]) x y) @@ -2395,7 +2387,7 @@ func rewriteValueARM_OpARMADDshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDshiftRL(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRL (MOVWconst [c]) x [d]) @@ -2456,7 +2448,7 @@ func rewriteValueARM_OpARMADDshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMADDshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMADDshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRLreg (MOVWconst [c]) x y) @@ -2497,9 +2489,7 @@ func rewriteValueARM_OpARMADDshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMAND(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMAND(v *Value) bool { // match: (AND (MOVWconst [c]) x) // cond: // result: (ANDconst [c] x) @@ -2881,9 +2871,7 @@ func rewriteValueARM_OpARMAND(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMANDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMANDconst(v *Value) bool { // match: (ANDconst [0] _) // cond: // result: (MOVWconst [0]) @@ -2941,7 +2929,7 @@ func rewriteValueARM_OpARMANDconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMANDshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMANDshiftLL(v *Value) bool { b := v.Block _ = b // match: (ANDshiftLL (MOVWconst [c]) x [d]) @@ -3003,7 +2991,7 @@ func rewriteValueARM_OpARMANDshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMANDshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMANDshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (ANDshiftLLreg (MOVWconst [c]) x y) @@ -3044,7 +3032,7 @@ func rewriteValueARM_OpARMANDshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMANDshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMANDshiftRA(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRA (MOVWconst [c]) x [d]) @@ -3106,7 +3094,7 @@ func rewriteValueARM_OpARMANDshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMANDshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMANDshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRAreg (MOVWconst [c]) x y) @@ -3147,7 +3135,7 @@ func rewriteValueARM_OpARMANDshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMANDshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMANDshiftRL(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRL (MOVWconst [c]) x [d]) @@ -3209,7 +3197,7 @@ func rewriteValueARM_OpARMANDshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMANDshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMANDshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRLreg (MOVWconst [c]) x y) @@ -3250,9 +3238,7 @@ func rewriteValueARM_OpARMANDshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMBIC(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMBIC(v *Value) bool { // match: (BIC x (MOVWconst [c])) // cond: // result: (BICconst [c] x) @@ -3384,9 +3370,7 @@ func rewriteValueARM_OpARMBIC(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMBICconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMBICconst(v *Value) bool { // match: (BICconst [0] x) // cond: // result: x @@ -3428,9 +3412,7 @@ func rewriteValueARM_OpARMBICconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMBICshiftLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMBICshiftLL(v *Value) bool { // match: (BICshiftLL x (MOVWconst [c]) [d]) // cond: // result: (BICconst x [int64(uint32(c)<<uint64(d))]) @@ -3470,9 +3452,7 @@ func rewriteValueARM_OpARMBICshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMBICshiftLLreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMBICshiftLLreg(v *Value) bool { // match: (BICshiftLLreg x y (MOVWconst [c])) // cond: // result: (BICshiftLL x y [c]) @@ -3492,9 +3472,7 @@ func rewriteValueARM_OpARMBICshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMBICshiftRA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMBICshiftRA(v *Value) bool { // match: (BICshiftRA x (MOVWconst [c]) [d]) // cond: // result: (BICconst x [int64(int32(c)>>uint64(d))]) @@ -3534,9 +3512,7 @@ func rewriteValueARM_OpARMBICshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMBICshiftRAreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMBICshiftRAreg(v *Value) bool { // match: (BICshiftRAreg x y (MOVWconst [c])) // cond: // result: (BICshiftRA x y [c]) @@ -3556,9 +3532,7 @@ func rewriteValueARM_OpARMBICshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMBICshiftRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMBICshiftRL(v *Value) bool { // match: (BICshiftRL x (MOVWconst [c]) [d]) // cond: // result: (BICconst x [int64(uint32(c)>>uint64(d))]) @@ -3598,9 +3572,7 @@ func rewriteValueARM_OpARMBICshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMBICshiftRLreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMBICshiftRLreg(v *Value) bool { // match: (BICshiftRLreg x y (MOVWconst [c])) // cond: // result: (BICshiftRL x y [c]) @@ -3620,9 +3592,7 @@ func rewriteValueARM_OpARMBICshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMOVWHSconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMCMOVWHSconst(v *Value) bool { // match: (CMOVWHSconst _ (FlagEQ) [c]) // cond: // result: (MOVWconst [c]) @@ -3709,9 +3679,7 @@ func rewriteValueARM_OpARMCMOVWHSconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMOVWLSconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMCMOVWLSconst(v *Value) bool { // match: (CMOVWLSconst _ (FlagEQ) [c]) // cond: // result: (MOVWconst [c]) @@ -3798,7 +3766,7 @@ func rewriteValueARM_OpARMCMOVWLSconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMP(v *Value, config *Config) bool { +func rewriteValueARM_OpARMCMP(v *Value) bool { b := v.Block _ = b // match: (CMP x (MOVWconst [c])) @@ -4051,9 +4019,7 @@ func rewriteValueARM_OpARMCMP(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMPD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMCMPD(v *Value) bool { // match: (CMPD x (MOVDconst [0])) // cond: // result: (CMPD0 x) @@ -4072,9 +4038,7 @@ func rewriteValueARM_OpARMCMPD(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMPF(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMCMPF(v *Value) bool { // match: (CMPF x (MOVFconst [0])) // cond: // result: (CMPF0 x) @@ -4093,9 +4057,7 @@ func rewriteValueARM_OpARMCMPF(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMPconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMCMPconst(v *Value) bool { // match: (CMPconst (MOVWconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -4240,7 +4202,7 @@ func rewriteValueARM_OpARMCMPconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMPshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMCMPshiftLL(v *Value) bool { b := v.Block _ = b // match: (CMPshiftLL (MOVWconst [c]) x [d]) @@ -4282,7 +4244,7 @@ func rewriteValueARM_OpARMCMPshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMPshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMCMPshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (CMPshiftLLreg (MOVWconst [c]) x y) @@ -4325,7 +4287,7 @@ func rewriteValueARM_OpARMCMPshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMPshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMCMPshiftRA(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRA (MOVWconst [c]) x [d]) @@ -4367,7 +4329,7 @@ func rewriteValueARM_OpARMCMPshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMPshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMCMPshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRAreg (MOVWconst [c]) x y) @@ -4410,7 +4372,7 @@ func rewriteValueARM_OpARMCMPshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMPshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMCMPshiftRL(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRL (MOVWconst [c]) x [d]) @@ -4452,7 +4414,7 @@ func rewriteValueARM_OpARMCMPshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMCMPshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMCMPshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRLreg (MOVWconst [c]) x y) @@ -4495,9 +4457,7 @@ func rewriteValueARM_OpARMCMPshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMEqual(v *Value) bool { // match: (Equal (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -4573,9 +4533,7 @@ func rewriteValueARM_OpARMEqual(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMGreaterEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMGreaterEqual(v *Value) bool { // match: (GreaterEqual (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -4651,9 +4609,7 @@ func rewriteValueARM_OpARMGreaterEqual(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMGreaterEqualU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMGreaterEqualU(v *Value) bool { // match: (GreaterEqualU (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -4729,9 +4685,7 @@ func rewriteValueARM_OpARMGreaterEqualU(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMGreaterThan(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMGreaterThan(v *Value) bool { // match: (GreaterThan (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -4807,9 +4761,7 @@ func rewriteValueARM_OpARMGreaterThan(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMGreaterThanU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMGreaterThanU(v *Value) bool { // match: (GreaterThanU (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -4885,9 +4837,7 @@ func rewriteValueARM_OpARMGreaterThanU(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMLessEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMLessEqual(v *Value) bool { // match: (LessEqual (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -4963,9 +4913,7 @@ func rewriteValueARM_OpARMLessEqual(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMLessEqualU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMLessEqualU(v *Value) bool { // match: (LessEqualU (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -5041,9 +4989,7 @@ func rewriteValueARM_OpARMLessEqualU(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMLessThan(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMLessThan(v *Value) bool { // match: (LessThan (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -5119,9 +5065,7 @@ func rewriteValueARM_OpARMLessThan(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMLessThanU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMLessThanU(v *Value) bool { // match: (LessThanU (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -5197,9 +5141,7 @@ func rewriteValueARM_OpARMLessThanU(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVBUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVBUload(v *Value) bool { // match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVBUload [off1+off2] {sym} ptr mem) @@ -5269,9 +5211,7 @@ func rewriteValueARM_OpARMMOVBUload(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVBUreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVBUreg(v *Value) bool { // match: (MOVBUreg x:(MOVBUload _ _)) // cond: // result: (MOVWreg x) @@ -5326,9 +5266,7 @@ func rewriteValueARM_OpARMMOVBUreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVBload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVBload(v *Value) bool { // match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -5398,9 +5336,7 @@ func rewriteValueARM_OpARMMOVBload(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVBreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVBreg(v *Value) bool { // match: (MOVBreg x:(MOVBload _ _)) // cond: // result: (MOVWreg x) @@ -5458,9 +5394,7 @@ func rewriteValueARM_OpARMMOVBreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVBstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVBstore(v *Value) bool { // match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: // result: (MOVBstore [off1+off2] {sym} ptr val mem) @@ -5595,9 +5529,7 @@ func rewriteValueARM_OpARMMOVBstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVDload(v *Value) bool { // match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVDload [off1+off2] {sym} ptr mem) @@ -5667,9 +5599,7 @@ func rewriteValueARM_OpARMMOVDload(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVDstore(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -5720,9 +5650,7 @@ func rewriteValueARM_OpARMMOVDstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVFload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVFload(v *Value) bool { // match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVFload [off1+off2] {sym} ptr mem) @@ -5792,9 +5720,7 @@ func rewriteValueARM_OpARMMOVFload(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVFstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVFstore(v *Value) bool { // match: (MOVFstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: // result: (MOVFstore [off1+off2] {sym} ptr val mem) @@ -5845,9 +5771,7 @@ func rewriteValueARM_OpARMMOVFstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVHUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVHUload(v *Value) bool { // match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVHUload [off1+off2] {sym} ptr mem) @@ -5917,9 +5841,7 @@ func rewriteValueARM_OpARMMOVHUload(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVHUreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVHUreg(v *Value) bool { // match: (MOVHUreg x:(MOVBUload _ _)) // cond: // result: (MOVWreg x) @@ -5998,9 +5920,7 @@ func rewriteValueARM_OpARMMOVHUreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVHload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVHload(v *Value) bool { // match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -6070,9 +5990,7 @@ func rewriteValueARM_OpARMMOVHload(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVHreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVHreg(v *Value) bool { // match: (MOVHreg x:(MOVBload _ _)) // cond: // result: (MOVWreg x) @@ -6178,9 +6096,7 @@ func rewriteValueARM_OpARMMOVHreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVHstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVHstore(v *Value) bool { // match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: // result: (MOVHstore [off1+off2] {sym} ptr val mem) @@ -6273,9 +6189,11 @@ func rewriteValueARM_OpARMMOVHstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWload(v *Value, config *Config) bool { +func rewriteValueARM_OpARMMOVWload(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVWload [off1+off2] {sym} ptr mem) @@ -6447,9 +6365,7 @@ func rewriteValueARM_OpARMMOVWload(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWloadidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVWloadidx(v *Value) bool { // match: (MOVWloadidx ptr idx (MOVWstoreidx ptr2 idx x _)) // cond: isSamePtr(ptr, ptr2) // result: x @@ -6623,9 +6539,7 @@ func rewriteValueARM_OpARMMOVWloadidx(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value) bool { // match: (MOVWloadshiftLL ptr idx [c] (MOVWstoreshiftLL ptr2 idx [d] x _)) // cond: c==d && isSamePtr(ptr, ptr2) // result: x @@ -6671,9 +6585,7 @@ func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value) bool { // match: (MOVWloadshiftRA ptr idx [c] (MOVWstoreshiftRA ptr2 idx [d] x _)) // cond: c==d && isSamePtr(ptr, ptr2) // result: x @@ -6719,9 +6631,7 @@ func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool { // match: (MOVWloadshiftRL ptr idx [c] (MOVWstoreshiftRL ptr2 idx [d] x _)) // cond: c==d && isSamePtr(ptr, ptr2) // result: x @@ -6767,9 +6677,7 @@ func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVWreg(v *Value) bool { // match: (MOVWreg x) // cond: x.Uses == 1 // result: (MOVWnop x) @@ -6797,9 +6705,11 @@ func rewriteValueARM_OpARMMOVWreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWstore(v *Value, config *Config) bool { +func rewriteValueARM_OpARMMOVWstore(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: // result: (MOVWstore [off1+off2] {sym} ptr val mem) @@ -6960,9 +6870,7 @@ func rewriteValueARM_OpARMMOVWstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWstoreidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVWstoreidx(v *Value) bool { // match: (MOVWstoreidx ptr (MOVWconst [c]) val mem) // cond: // result: (MOVWstore [c] ptr val mem) @@ -7129,9 +7037,7 @@ func rewriteValueARM_OpARMMOVWstoreidx(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value) bool { // match: (MOVWstoreshiftLL ptr (MOVWconst [c]) [d] val mem) // cond: // result: (MOVWstore [int64(uint32(c)<<uint64(d))] ptr val mem) @@ -7154,9 +7060,7 @@ func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value) bool { // match: (MOVWstoreshiftRA ptr (MOVWconst [c]) [d] val mem) // cond: // result: (MOVWstore [int64(int32(c)>>uint64(d))] ptr val mem) @@ -7179,9 +7083,7 @@ func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value) bool { // match: (MOVWstoreshiftRL ptr (MOVWconst [c]) [d] val mem) // cond: // result: (MOVWstore [int64(uint32(c)>>uint64(d))] ptr val mem) @@ -7204,7 +7106,7 @@ func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMUL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMMUL(v *Value) bool { b := v.Block _ = b // match: (MUL x (MOVWconst [c])) @@ -7615,7 +7517,7 @@ func rewriteValueARM_OpARMMUL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMULA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMMULA(v *Value) bool { b := v.Block _ = b // match: (MULA x (MOVWconst [c]) a) @@ -8092,9 +7994,7 @@ func rewriteValueARM_OpARMMULA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMVN(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMVN(v *Value) bool { // match: (MVN (MOVWconst [c])) // cond: // result: (MOVWconst [^c]) @@ -8200,9 +8100,7 @@ func rewriteValueARM_OpARMMVN(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMVNshiftLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMVNshiftLL(v *Value) bool { // match: (MVNshiftLL (MOVWconst [c]) [d]) // cond: // result: (MOVWconst [^int64(uint32(c)<<uint64(d))]) @@ -8219,9 +8117,7 @@ func rewriteValueARM_OpARMMVNshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMVNshiftLLreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMVNshiftLLreg(v *Value) bool { // match: (MVNshiftLLreg x (MOVWconst [c])) // cond: // result: (MVNshiftLL x [c]) @@ -8239,9 +8135,7 @@ func rewriteValueARM_OpARMMVNshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMVNshiftRA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMVNshiftRA(v *Value) bool { // match: (MVNshiftRA (MOVWconst [c]) [d]) // cond: // result: (MOVWconst [^int64(int32(c)>>uint64(d))]) @@ -8258,9 +8152,7 @@ func rewriteValueARM_OpARMMVNshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMVNshiftRAreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMVNshiftRAreg(v *Value) bool { // match: (MVNshiftRAreg x (MOVWconst [c])) // cond: // result: (MVNshiftRA x [c]) @@ -8278,9 +8170,7 @@ func rewriteValueARM_OpARMMVNshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMVNshiftRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMVNshiftRL(v *Value) bool { // match: (MVNshiftRL (MOVWconst [c]) [d]) // cond: // result: (MOVWconst [^int64(uint32(c)>>uint64(d))]) @@ -8297,9 +8187,7 @@ func rewriteValueARM_OpARMMVNshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMMVNshiftRLreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool { // match: (MVNshiftRLreg x (MOVWconst [c])) // cond: // result: (MVNshiftRL x [c]) @@ -8317,9 +8205,7 @@ func rewriteValueARM_OpARMMVNshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMNotEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMNotEqual(v *Value) bool { // match: (NotEqual (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -8395,9 +8281,7 @@ func rewriteValueARM_OpARMNotEqual(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMOR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMOR(v *Value) bool { // match: (OR (MOVWconst [c]) x) // cond: // result: (ORconst [c] x) @@ -8647,9 +8531,7 @@ func rewriteValueARM_OpARMOR(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMORconst(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -8707,7 +8589,7 @@ func rewriteValueARM_OpARMORconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMORshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMORshiftLL(v *Value) bool { b := v.Block _ = b // match: (ORshiftLL (MOVWconst [c]) x [d]) @@ -8790,7 +8672,7 @@ func rewriteValueARM_OpARMORshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMORshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMORshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (ORshiftLLreg (MOVWconst [c]) x y) @@ -8831,7 +8713,7 @@ func rewriteValueARM_OpARMORshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMORshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMORshiftRA(v *Value) bool { b := v.Block _ = b // match: (ORshiftRA (MOVWconst [c]) x [d]) @@ -8893,7 +8775,7 @@ func rewriteValueARM_OpARMORshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMORshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMORshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (ORshiftRAreg (MOVWconst [c]) x y) @@ -8934,7 +8816,7 @@ func rewriteValueARM_OpARMORshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMORshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMORshiftRL(v *Value) bool { b := v.Block _ = b // match: (ORshiftRL (MOVWconst [c]) x [d]) @@ -9017,7 +8899,7 @@ func rewriteValueARM_OpARMORshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMORshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMORshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (ORshiftRLreg (MOVWconst [c]) x y) @@ -9058,9 +8940,7 @@ func rewriteValueARM_OpARMORshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMRSB(v *Value) bool { // match: (RSB (MOVWconst [c]) x) // cond: // result: (SUBconst [c] x) @@ -9309,7 +9189,7 @@ func rewriteValueARM_OpARMRSB(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBSshiftLL(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftLL (MOVWconst [c]) x [d]) @@ -9349,7 +9229,7 @@ func rewriteValueARM_OpARMRSBSshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftLLreg (MOVWconst [c]) x y) @@ -9390,7 +9270,7 @@ func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBSshiftRA(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftRA (MOVWconst [c]) x [d]) @@ -9430,7 +9310,7 @@ func rewriteValueARM_OpARMRSBSshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftRAreg (MOVWconst [c]) x y) @@ -9471,7 +9351,7 @@ func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBSshiftRL(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftRL (MOVWconst [c]) x [d]) @@ -9511,7 +9391,7 @@ func rewriteValueARM_OpARMRSBSshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftRLreg (MOVWconst [c]) x y) @@ -9552,9 +9432,7 @@ func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMRSBconst(v *Value) bool { // match: (RSBconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(int32(c-d))]) @@ -9619,7 +9497,7 @@ func rewriteValueARM_OpARMRSBconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBshiftLL(v *Value) bool { b := v.Block _ = b // match: (RSBshiftLL (MOVWconst [c]) x [d]) @@ -9680,7 +9558,7 @@ func rewriteValueARM_OpARMRSBshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (RSBshiftLLreg (MOVWconst [c]) x y) @@ -9721,7 +9599,7 @@ func rewriteValueARM_OpARMRSBshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBshiftRA(v *Value) bool { b := v.Block _ = b // match: (RSBshiftRA (MOVWconst [c]) x [d]) @@ -9782,7 +9660,7 @@ func rewriteValueARM_OpARMRSBshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (RSBshiftRAreg (MOVWconst [c]) x y) @@ -9823,7 +9701,7 @@ func rewriteValueARM_OpARMRSBshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBshiftRL(v *Value) bool { b := v.Block _ = b // match: (RSBshiftRL (MOVWconst [c]) x [d]) @@ -9884,7 +9762,7 @@ func rewriteValueARM_OpARMRSBshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSBshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSBshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (RSBshiftRLreg (MOVWconst [c]) x y) @@ -9925,9 +9803,7 @@ func rewriteValueARM_OpARMRSBshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSCconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMRSCconst(v *Value) bool { // match: (RSCconst [c] (ADDconst [d] x) flags) // cond: // result: (RSCconst [int64(int32(c-d))] x flags) @@ -9966,7 +9842,7 @@ func rewriteValueARM_OpARMRSCconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSCshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSCshiftLL(v *Value) bool { b := v.Block _ = b // match: (RSCshiftLL (MOVWconst [c]) x [d] flags) @@ -10010,7 +9886,7 @@ func rewriteValueARM_OpARMRSCshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSCshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSCshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (RSCshiftLLreg (MOVWconst [c]) x y flags) @@ -10055,7 +9931,7 @@ func rewriteValueARM_OpARMRSCshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSCshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSCshiftRA(v *Value) bool { b := v.Block _ = b // match: (RSCshiftRA (MOVWconst [c]) x [d] flags) @@ -10099,7 +9975,7 @@ func rewriteValueARM_OpARMRSCshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSCshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSCshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (RSCshiftRAreg (MOVWconst [c]) x y flags) @@ -10144,7 +10020,7 @@ func rewriteValueARM_OpARMRSCshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSCshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSCshiftRL(v *Value) bool { b := v.Block _ = b // match: (RSCshiftRL (MOVWconst [c]) x [d] flags) @@ -10188,7 +10064,7 @@ func rewriteValueARM_OpARMRSCshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMRSCshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMRSCshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (RSCshiftRLreg (MOVWconst [c]) x y flags) @@ -10233,9 +10109,7 @@ func rewriteValueARM_OpARMRSCshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSBC(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSBC(v *Value) bool { // match: (SBC (MOVWconst [c]) x flags) // cond: // result: (RSCconst [c] x flags) @@ -10500,9 +10374,7 @@ func rewriteValueARM_OpARMSBC(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSBCconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSBCconst(v *Value) bool { // match: (SBCconst [c] (ADDconst [d] x) flags) // cond: // result: (SBCconst [int64(int32(c-d))] x flags) @@ -10541,7 +10413,7 @@ func rewriteValueARM_OpARMSBCconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSBCshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSBCshiftLL(v *Value) bool { b := v.Block _ = b // match: (SBCshiftLL (MOVWconst [c]) x [d] flags) @@ -10585,7 +10457,7 @@ func rewriteValueARM_OpARMSBCshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSBCshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSBCshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (SBCshiftLLreg (MOVWconst [c]) x y flags) @@ -10630,7 +10502,7 @@ func rewriteValueARM_OpARMSBCshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSBCshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSBCshiftRA(v *Value) bool { b := v.Block _ = b // match: (SBCshiftRA (MOVWconst [c]) x [d] flags) @@ -10674,7 +10546,7 @@ func rewriteValueARM_OpARMSBCshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSBCshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSBCshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (SBCshiftRAreg (MOVWconst [c]) x y flags) @@ -10719,7 +10591,7 @@ func rewriteValueARM_OpARMSBCshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSBCshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSBCshiftRL(v *Value) bool { b := v.Block _ = b // match: (SBCshiftRL (MOVWconst [c]) x [d] flags) @@ -10763,7 +10635,7 @@ func rewriteValueARM_OpARMSBCshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSBCshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSBCshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (SBCshiftRLreg (MOVWconst [c]) x y flags) @@ -10808,9 +10680,7 @@ func rewriteValueARM_OpARMSBCshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSLL(v *Value) bool { // match: (SLL x (MOVWconst [c])) // cond: // result: (SLLconst x [c&31]) @@ -10828,9 +10698,7 @@ func rewriteValueARM_OpARMSLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSLLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSLLconst(v *Value) bool { // match: (SLLconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(uint32(d)<<uint64(c))]) @@ -10847,9 +10715,7 @@ func rewriteValueARM_OpARMSLLconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSRA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSRA(v *Value) bool { // match: (SRA x (MOVWconst [c])) // cond: // result: (SRAconst x [c&31]) @@ -10867,9 +10733,7 @@ func rewriteValueARM_OpARMSRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSRAcond(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSRAcond(v *Value) bool { // match: (SRAcond x _ (FlagEQ)) // cond: // result: (SRAconst x [31]) @@ -10944,9 +10808,7 @@ func rewriteValueARM_OpARMSRAcond(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSRAconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSRAconst(v *Value) bool { // match: (SRAconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(int32(d)>>uint64(c))]) @@ -10963,9 +10825,7 @@ func rewriteValueARM_OpARMSRAconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSRL(v *Value) bool { // match: (SRL x (MOVWconst [c])) // cond: // result: (SRLconst x [c&31]) @@ -10983,9 +10843,7 @@ func rewriteValueARM_OpARMSRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSRLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSRLconst(v *Value) bool { // match: (SRLconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(uint32(d)>>uint64(c))]) @@ -11002,9 +10860,7 @@ func rewriteValueARM_OpARMSRLconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSUB(v *Value) bool { // match: (SUB (MOVWconst [c]) x) // cond: // result: (RSBconst [c] x) @@ -11253,9 +11109,7 @@ func rewriteValueARM_OpARMSUB(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBS(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSUBS(v *Value) bool { // match: (SUBS (MOVWconst [c]) x) // cond: // result: (RSBSconst [c] x) @@ -11492,7 +11346,7 @@ func rewriteValueARM_OpARMSUBS(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBSshiftLL(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftLL (MOVWconst [c]) x [d]) @@ -11532,7 +11386,7 @@ func rewriteValueARM_OpARMSUBSshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftLLreg (MOVWconst [c]) x y) @@ -11573,7 +11427,7 @@ func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBSshiftRA(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftRA (MOVWconst [c]) x [d]) @@ -11613,7 +11467,7 @@ func rewriteValueARM_OpARMSUBSshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftRAreg (MOVWconst [c]) x y) @@ -11654,7 +11508,7 @@ func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBSshiftRL(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftRL (MOVWconst [c]) x [d]) @@ -11694,7 +11548,7 @@ func rewriteValueARM_OpARMSUBSshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftRLreg (MOVWconst [c]) x y) @@ -11735,9 +11589,7 @@ func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMSUBconst(v *Value) bool { // match: (SUBconst [0] x) // cond: // result: x @@ -11815,7 +11667,7 @@ func rewriteValueARM_OpARMSUBconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBshiftLL(v *Value) bool { b := v.Block _ = b // match: (SUBshiftLL (MOVWconst [c]) x [d]) @@ -11876,7 +11728,7 @@ func rewriteValueARM_OpARMSUBshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (SUBshiftLLreg (MOVWconst [c]) x y) @@ -11917,7 +11769,7 @@ func rewriteValueARM_OpARMSUBshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBshiftRA(v *Value) bool { b := v.Block _ = b // match: (SUBshiftRA (MOVWconst [c]) x [d]) @@ -11978,7 +11830,7 @@ func rewriteValueARM_OpARMSUBshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (SUBshiftRAreg (MOVWconst [c]) x y) @@ -12019,7 +11871,7 @@ func rewriteValueARM_OpARMSUBshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBshiftRL(v *Value) bool { b := v.Block _ = b // match: (SUBshiftRL (MOVWconst [c]) x [d]) @@ -12080,7 +11932,7 @@ func rewriteValueARM_OpARMSUBshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMSUBshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMSUBshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (SUBshiftRLreg (MOVWconst [c]) x y) @@ -12121,9 +11973,7 @@ func rewriteValueARM_OpARMSUBshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMXOR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMXOR(v *Value) bool { // match: (XOR (MOVWconst [c]) x) // cond: // result: (XORconst [c] x) @@ -12406,9 +12256,7 @@ func rewriteValueARM_OpARMXOR(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMXORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMXORconst(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -12454,7 +12302,7 @@ func rewriteValueARM_OpARMXORconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMXORshiftLL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMXORshiftLL(v *Value) bool { b := v.Block _ = b // match: (XORshiftLL (MOVWconst [c]) x [d]) @@ -12536,7 +12384,7 @@ func rewriteValueARM_OpARMXORshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMXORshiftLLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMXORshiftLLreg(v *Value) bool { b := v.Block _ = b // match: (XORshiftLLreg (MOVWconst [c]) x y) @@ -12577,7 +12425,7 @@ func rewriteValueARM_OpARMXORshiftLLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMXORshiftRA(v *Value, config *Config) bool { +func rewriteValueARM_OpARMXORshiftRA(v *Value) bool { b := v.Block _ = b // match: (XORshiftRA (MOVWconst [c]) x [d]) @@ -12638,7 +12486,7 @@ func rewriteValueARM_OpARMXORshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMXORshiftRAreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMXORshiftRAreg(v *Value) bool { b := v.Block _ = b // match: (XORshiftRAreg (MOVWconst [c]) x y) @@ -12679,7 +12527,7 @@ func rewriteValueARM_OpARMXORshiftRAreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMXORshiftRL(v *Value, config *Config) bool { +func rewriteValueARM_OpARMXORshiftRL(v *Value) bool { b := v.Block _ = b // match: (XORshiftRL (MOVWconst [c]) x [d]) @@ -12761,7 +12609,7 @@ func rewriteValueARM_OpARMXORshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMXORshiftRLreg(v *Value, config *Config) bool { +func rewriteValueARM_OpARMXORshiftRLreg(v *Value) bool { b := v.Block _ = b // match: (XORshiftRLreg (MOVWconst [c]) x y) @@ -12802,7 +12650,7 @@ func rewriteValueARM_OpARMXORshiftRLreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpARMXORshiftRR(v *Value, config *Config) bool { +func rewriteValueARM_OpARMXORshiftRR(v *Value) bool { b := v.Block _ = b // match: (XORshiftRR (MOVWconst [c]) x [d]) @@ -12842,9 +12690,7 @@ func rewriteValueARM_OpARMXORshiftRR(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpAdd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAdd16(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADD x y) @@ -12857,9 +12703,7 @@ func rewriteValueARM_OpAdd16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAdd32(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADD x y) @@ -12872,9 +12716,7 @@ func rewriteValueARM_OpAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAdd32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAdd32F(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDF x y) @@ -12887,9 +12729,7 @@ func rewriteValueARM_OpAdd32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAdd32carry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAdd32carry(v *Value) bool { // match: (Add32carry x y) // cond: // result: (ADDS x y) @@ -12902,9 +12742,7 @@ func rewriteValueARM_OpAdd32carry(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAdd32withcarry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAdd32withcarry(v *Value) bool { // match: (Add32withcarry x y c) // cond: // result: (ADC x y c) @@ -12919,9 +12757,7 @@ func rewriteValueARM_OpAdd32withcarry(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAdd64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAdd64F(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDD x y) @@ -12934,9 +12770,7 @@ func rewriteValueARM_OpAdd64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAdd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAdd8(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADD x y) @@ -12949,9 +12783,7 @@ func rewriteValueARM_OpAdd8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAddPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAddPtr(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -12964,9 +12796,7 @@ func rewriteValueARM_OpAddPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAddr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAddr(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVWaddr {sym} base) @@ -12979,9 +12809,7 @@ func rewriteValueARM_OpAddr(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAnd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAnd16(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -12994,9 +12822,7 @@ func rewriteValueARM_OpAnd16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAnd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAnd32(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -13009,9 +12835,7 @@ func rewriteValueARM_OpAnd32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAnd8(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -13024,9 +12848,7 @@ func rewriteValueARM_OpAnd8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAndB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpAndB(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -13039,7 +12861,7 @@ func rewriteValueARM_OpAndB(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpAvg32u(v *Value, config *Config) bool { +func rewriteValueARM_OpAvg32u(v *Value) bool { b := v.Block _ = b // match: (Avg32u <t> x y) @@ -13061,7 +12883,7 @@ func rewriteValueARM_OpAvg32u(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpBitLen32(v *Value, config *Config) bool { +func rewriteValueARM_OpBitLen32(v *Value) bool { b := v.Block _ = b // match: (BitLen32 <t> x) @@ -13078,7 +12900,7 @@ func rewriteValueARM_OpBitLen32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpBswap32(v *Value, config *Config) bool { +func rewriteValueARM_OpBswap32(v *Value) bool { b := v.Block _ = b // match: (Bswap32 <t> x) @@ -13109,9 +12931,7 @@ func rewriteValueARM_OpBswap32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpClosureCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpClosureCall(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -13128,9 +12948,7 @@ func rewriteValueARM_OpClosureCall(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCom16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCom16(v *Value) bool { // match: (Com16 x) // cond: // result: (MVN x) @@ -13141,9 +12959,7 @@ func rewriteValueARM_OpCom16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCom32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCom32(v *Value) bool { // match: (Com32 x) // cond: // result: (MVN x) @@ -13154,9 +12970,7 @@ func rewriteValueARM_OpCom32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCom8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCom8(v *Value) bool { // match: (Com8 x) // cond: // result: (MVN x) @@ -13167,9 +12981,7 @@ func rewriteValueARM_OpCom8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpConst16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpConst16(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVWconst [val]) @@ -13180,9 +12992,7 @@ func rewriteValueARM_OpConst16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpConst32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpConst32(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVWconst [val]) @@ -13193,9 +13003,7 @@ func rewriteValueARM_OpConst32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpConst32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpConst32F(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVFconst [val]) @@ -13206,9 +13014,7 @@ func rewriteValueARM_OpConst32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpConst64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpConst64F(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVDconst [val]) @@ -13219,9 +13025,7 @@ func rewriteValueARM_OpConst64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpConst8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpConst8(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVWconst [val]) @@ -13232,9 +13036,7 @@ func rewriteValueARM_OpConst8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpConstBool(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpConstBool(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVWconst [b]) @@ -13245,9 +13047,7 @@ func rewriteValueARM_OpConstBool(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpConstNil(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpConstNil(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVWconst [0]) @@ -13257,9 +13057,7 @@ func rewriteValueARM_OpConstNil(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpConvert(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpConvert(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVWconvert x mem) @@ -13272,7 +13070,7 @@ func rewriteValueARM_OpConvert(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCtz32(v *Value, config *Config) bool { +func rewriteValueARM_OpCtz32(v *Value) bool { b := v.Block _ = b // match: (Ctz32 <t> x) @@ -13298,9 +13096,7 @@ func rewriteValueARM_OpCtz32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt32Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt32Fto32(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (MOVFW x) @@ -13311,9 +13107,7 @@ func rewriteValueARM_OpCvt32Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt32Fto32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt32Fto32U(v *Value) bool { // match: (Cvt32Fto32U x) // cond: // result: (MOVFWU x) @@ -13324,9 +13118,7 @@ func rewriteValueARM_OpCvt32Fto32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt32Fto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt32Fto64F(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (MOVFD x) @@ -13337,9 +13129,7 @@ func rewriteValueARM_OpCvt32Fto64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt32Uto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt32Uto32F(v *Value) bool { // match: (Cvt32Uto32F x) // cond: // result: (MOVWUF x) @@ -13350,9 +13140,7 @@ func rewriteValueARM_OpCvt32Uto32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt32Uto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt32Uto64F(v *Value) bool { // match: (Cvt32Uto64F x) // cond: // result: (MOVWUD x) @@ -13363,9 +13151,7 @@ func rewriteValueARM_OpCvt32Uto64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt32to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt32to32F(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (MOVWF x) @@ -13376,9 +13162,7 @@ func rewriteValueARM_OpCvt32to32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt32to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt32to64F(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (MOVWD x) @@ -13389,9 +13173,7 @@ func rewriteValueARM_OpCvt32to64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt64Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt64Fto32(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (MOVDW x) @@ -13402,9 +13184,7 @@ func rewriteValueARM_OpCvt64Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt64Fto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt64Fto32F(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (MOVDF x) @@ -13415,9 +13195,7 @@ func rewriteValueARM_OpCvt64Fto32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpCvt64Fto32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpCvt64Fto32U(v *Value) bool { // match: (Cvt64Fto32U x) // cond: // result: (MOVDWU x) @@ -13428,9 +13206,13 @@ func rewriteValueARM_OpCvt64Fto32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpDiv16(v *Value, config *Config) bool { +func rewriteValueARM_OpDiv16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16 x y) // cond: // result: (Div32 (SignExt16to32 x) (SignExt16to32 y)) @@ -13438,18 +13220,22 @@ func rewriteValueARM_OpDiv16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpDiv32) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpDiv16u(v *Value, config *Config) bool { +func rewriteValueARM_OpDiv16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16u x y) // cond: // result: (Div32u (ZeroExt16to32 x) (ZeroExt16to32 y)) @@ -13457,62 +13243,66 @@ func rewriteValueARM_OpDiv16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpDiv32u) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpDiv32(v *Value, config *Config) bool { +func rewriteValueARM_OpDiv32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32 x y) // cond: - // result: (SUB (XOR <config.fe.TypeUInt32()> (Select0 <config.fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (SUB <config.fe.TypeUInt32()> (XOR x <config.fe.TypeUInt32()> (Signmask x)) (Signmask x)) (SUB <config.fe.TypeUInt32()> (XOR y <config.fe.TypeUInt32()> (Signmask y)) (Signmask y)))) (Signmask (XOR <config.fe.TypeUInt32()> x y))) (Signmask (XOR <config.fe.TypeUInt32()> x y))) + // result: (SUB (XOR <fe.TypeUInt32()> (Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (SUB <fe.TypeUInt32()> (XOR x <fe.TypeUInt32()> (Signmask x)) (Signmask x)) (SUB <fe.TypeUInt32()> (XOR y <fe.TypeUInt32()> (Signmask y)) (Signmask y)))) (Signmask (XOR <fe.TypeUInt32()> x y))) (Signmask (XOR <fe.TypeUInt32()> x y))) for { x := v.Args[0] y := v.Args[1] v.reset(OpARMSUB) - v0 := b.NewValue0(v.Pos, OpARMXOR, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpSelect0, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) + v0 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpSelect0, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v2.Aux = config.ctxt.Lookup("udiv", 0) - v3 := b.NewValue0(v.Pos, OpARMSUB, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpARMXOR, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpARMSUB, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32()) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v5 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v5.AddArg(x) v4.AddArg(v5) v3.AddArg(v4) - v6 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v6 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v6.AddArg(x) v3.AddArg(v6) v2.AddArg(v3) - v7 := b.NewValue0(v.Pos, OpARMSUB, config.fe.TypeUInt32()) - v8 := b.NewValue0(v.Pos, OpARMXOR, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpARMSUB, fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32()) v8.AddArg(y) - v9 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v9 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v9.AddArg(y) v8.AddArg(v9) v7.AddArg(v8) - v10 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v10 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v10.AddArg(y) v7.AddArg(v10) v2.AddArg(v7) v1.AddArg(v2) v0.AddArg(v1) - v11 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) - v12 := b.NewValue0(v.Pos, OpARMXOR, config.fe.TypeUInt32()) + v11 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) + v12 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32()) v12.AddArg(x) v12.AddArg(y) v11.AddArg(v12) v0.AddArg(v11) v.AddArg(v0) - v13 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) - v14 := b.NewValue0(v.Pos, OpARMXOR, config.fe.TypeUInt32()) + v13 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) + v14 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32()) v14.AddArg(x) v14.AddArg(y) v13.AddArg(v14) @@ -13520,9 +13310,7 @@ func rewriteValueARM_OpDiv32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpDiv32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpDiv32F(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVF x y) @@ -13535,18 +13323,22 @@ func rewriteValueARM_OpDiv32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpDiv32u(v *Value, config *Config) bool { +func rewriteValueARM_OpDiv32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32u x y) // cond: - // result: (Select0 <config.fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) + // result: (Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) for { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v.Type = config.fe.TypeUInt32() - v0 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) + v.Type = fe.TypeUInt32() + v0 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v0.Aux = config.ctxt.Lookup("udiv", 0) v0.AddArg(x) v0.AddArg(y) @@ -13554,9 +13346,7 @@ func rewriteValueARM_OpDiv32u(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpDiv64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpDiv64F(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVD x y) @@ -13569,9 +13359,13 @@ func rewriteValueARM_OpDiv64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpDiv8(v *Value, config *Config) bool { +func rewriteValueARM_OpDiv8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8 x y) // cond: // result: (Div32 (SignExt8to32 x) (SignExt8to32 y)) @@ -13579,18 +13373,22 @@ func rewriteValueARM_OpDiv8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpDiv32) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpDiv8u(v *Value, config *Config) bool { +func rewriteValueARM_OpDiv8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8u x y) // cond: // result: (Div32u (ZeroExt8to32 x) (ZeroExt8to32 y)) @@ -13598,18 +13396,22 @@ func rewriteValueARM_OpDiv8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpDiv32u) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpEq16(v *Value, config *Config) bool { +func rewriteValueARM_OpEq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq16 x y) // cond: // result: (Equal (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -13618,17 +13420,17 @@ func rewriteValueARM_OpEq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMEqual) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpEq32(v *Value, config *Config) bool { +func rewriteValueARM_OpEq32(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -13645,7 +13447,7 @@ func rewriteValueARM_OpEq32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpEq32F(v *Value, config *Config) bool { +func rewriteValueARM_OpEq32F(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -13662,7 +13464,7 @@ func rewriteValueARM_OpEq32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpEq64F(v *Value, config *Config) bool { +func rewriteValueARM_OpEq64F(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -13679,9 +13481,13 @@ func rewriteValueARM_OpEq64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpEq8(v *Value, config *Config) bool { +func rewriteValueARM_OpEq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq8 x y) // cond: // result: (Equal (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -13690,35 +13496,39 @@ func rewriteValueARM_OpEq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMEqual) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpEqB(v *Value, config *Config) bool { +func rewriteValueARM_OpEqB(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqB x y) // cond: - // result: (XORconst [1] (XOR <config.fe.TypeBool()> x y)) + // result: (XORconst [1] (XOR <fe.TypeBool()> x y)) for { x := v.Args[0] y := v.Args[1] v.reset(OpARMXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpARMXOR, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeBool()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueARM_OpEqPtr(v *Value, config *Config) bool { +func rewriteValueARM_OpEqPtr(v *Value) bool { b := v.Block _ = b // match: (EqPtr x y) @@ -13735,9 +13545,13 @@ func rewriteValueARM_OpEqPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGeq16(v *Value, config *Config) bool { +func rewriteValueARM_OpGeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16 x y) // cond: // result: (GreaterEqual (CMP (SignExt16to32 x) (SignExt16to32 y))) @@ -13746,19 +13560,23 @@ func rewriteValueARM_OpGeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMGreaterEqual) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpGeq16U(v *Value, config *Config) bool { +func rewriteValueARM_OpGeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16U x y) // cond: // result: (GreaterEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -13767,17 +13585,17 @@ func rewriteValueARM_OpGeq16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMGreaterEqualU) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpGeq32(v *Value, config *Config) bool { +func rewriteValueARM_OpGeq32(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -13794,7 +13612,7 @@ func rewriteValueARM_OpGeq32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGeq32F(v *Value, config *Config) bool { +func rewriteValueARM_OpGeq32F(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -13811,7 +13629,7 @@ func rewriteValueARM_OpGeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGeq32U(v *Value, config *Config) bool { +func rewriteValueARM_OpGeq32U(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -13828,7 +13646,7 @@ func rewriteValueARM_OpGeq32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGeq64F(v *Value, config *Config) bool { +func rewriteValueARM_OpGeq64F(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -13845,9 +13663,13 @@ func rewriteValueARM_OpGeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGeq8(v *Value, config *Config) bool { +func rewriteValueARM_OpGeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8 x y) // cond: // result: (GreaterEqual (CMP (SignExt8to32 x) (SignExt8to32 y))) @@ -13856,19 +13678,23 @@ func rewriteValueARM_OpGeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMGreaterEqual) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpGeq8U(v *Value, config *Config) bool { +func rewriteValueARM_OpGeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8U x y) // cond: // result: (GreaterEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -13877,19 +13703,17 @@ func rewriteValueARM_OpGeq8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMGreaterEqualU) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpGetClosurePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -13898,9 +13722,13 @@ func rewriteValueARM_OpGetClosurePtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGreater16(v *Value, config *Config) bool { +func rewriteValueARM_OpGreater16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16 x y) // cond: // result: (GreaterThan (CMP (SignExt16to32 x) (SignExt16to32 y))) @@ -13909,19 +13737,23 @@ func rewriteValueARM_OpGreater16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMGreaterThan) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpGreater16U(v *Value, config *Config) bool { +func rewriteValueARM_OpGreater16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16U x y) // cond: // result: (GreaterThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -13930,17 +13762,17 @@ func rewriteValueARM_OpGreater16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMGreaterThanU) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpGreater32(v *Value, config *Config) bool { +func rewriteValueARM_OpGreater32(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -13957,7 +13789,7 @@ func rewriteValueARM_OpGreater32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGreater32F(v *Value, config *Config) bool { +func rewriteValueARM_OpGreater32F(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -13974,7 +13806,7 @@ func rewriteValueARM_OpGreater32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGreater32U(v *Value, config *Config) bool { +func rewriteValueARM_OpGreater32U(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -13991,7 +13823,7 @@ func rewriteValueARM_OpGreater32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGreater64F(v *Value, config *Config) bool { +func rewriteValueARM_OpGreater64F(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -14008,9 +13840,13 @@ func rewriteValueARM_OpGreater64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpGreater8(v *Value, config *Config) bool { +func rewriteValueARM_OpGreater8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8 x y) // cond: // result: (GreaterThan (CMP (SignExt8to32 x) (SignExt8to32 y))) @@ -14019,19 +13855,23 @@ func rewriteValueARM_OpGreater8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMGreaterThan) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpGreater8U(v *Value, config *Config) bool { +func rewriteValueARM_OpGreater8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8U x y) // cond: // result: (GreaterThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -14040,19 +13880,17 @@ func rewriteValueARM_OpGreater8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMGreaterThanU) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpHmul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpHmul32(v *Value) bool { // match: (Hmul32 x y) // cond: // result: (HMUL x y) @@ -14065,9 +13903,7 @@ func rewriteValueARM_OpHmul32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpHmul32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpHmul32u(v *Value) bool { // match: (Hmul32u x y) // cond: // result: (HMULU x y) @@ -14080,9 +13916,7 @@ func rewriteValueARM_OpHmul32u(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpInterCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpInterCall(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -14097,7 +13931,7 @@ func rewriteValueARM_OpInterCall(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpIsInBounds(v *Value, config *Config) bool { +func rewriteValueARM_OpIsInBounds(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -14114,7 +13948,7 @@ func rewriteValueARM_OpIsInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpIsNonNil(v *Value, config *Config) bool { +func rewriteValueARM_OpIsNonNil(v *Value) bool { b := v.Block _ = b // match: (IsNonNil ptr) @@ -14130,7 +13964,7 @@ func rewriteValueARM_OpIsNonNil(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpIsSliceInBounds(v *Value, config *Config) bool { +func rewriteValueARM_OpIsSliceInBounds(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -14147,9 +13981,13 @@ func rewriteValueARM_OpIsSliceInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLeq16(v *Value, config *Config) bool { +func rewriteValueARM_OpLeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16 x y) // cond: // result: (LessEqual (CMP (SignExt16to32 x) (SignExt16to32 y))) @@ -14158,19 +13996,23 @@ func rewriteValueARM_OpLeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMLessEqual) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpLeq16U(v *Value, config *Config) bool { +func rewriteValueARM_OpLeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16U x y) // cond: // result: (LessEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -14179,17 +14021,17 @@ func rewriteValueARM_OpLeq16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMLessEqualU) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpLeq32(v *Value, config *Config) bool { +func rewriteValueARM_OpLeq32(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -14206,7 +14048,7 @@ func rewriteValueARM_OpLeq32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLeq32F(v *Value, config *Config) bool { +func rewriteValueARM_OpLeq32F(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -14223,7 +14065,7 @@ func rewriteValueARM_OpLeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLeq32U(v *Value, config *Config) bool { +func rewriteValueARM_OpLeq32U(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -14240,7 +14082,7 @@ func rewriteValueARM_OpLeq32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLeq64F(v *Value, config *Config) bool { +func rewriteValueARM_OpLeq64F(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -14257,9 +14099,13 @@ func rewriteValueARM_OpLeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLeq8(v *Value, config *Config) bool { +func rewriteValueARM_OpLeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8 x y) // cond: // result: (LessEqual (CMP (SignExt8to32 x) (SignExt8to32 y))) @@ -14268,19 +14114,23 @@ func rewriteValueARM_OpLeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMLessEqual) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpLeq8U(v *Value, config *Config) bool { +func rewriteValueARM_OpLeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8U x y) // cond: // result: (LessEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -14289,19 +14139,23 @@ func rewriteValueARM_OpLeq8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMLessEqualU) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpLess16(v *Value, config *Config) bool { +func rewriteValueARM_OpLess16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16 x y) // cond: // result: (LessThan (CMP (SignExt16to32 x) (SignExt16to32 y))) @@ -14310,19 +14164,23 @@ func rewriteValueARM_OpLess16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMLessThan) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpLess16U(v *Value, config *Config) bool { +func rewriteValueARM_OpLess16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16U x y) // cond: // result: (LessThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -14331,17 +14189,17 @@ func rewriteValueARM_OpLess16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMLessThanU) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpLess32(v *Value, config *Config) bool { +func rewriteValueARM_OpLess32(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -14358,7 +14216,7 @@ func rewriteValueARM_OpLess32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLess32F(v *Value, config *Config) bool { +func rewriteValueARM_OpLess32F(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -14375,7 +14233,7 @@ func rewriteValueARM_OpLess32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLess32U(v *Value, config *Config) bool { +func rewriteValueARM_OpLess32U(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -14392,7 +14250,7 @@ func rewriteValueARM_OpLess32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLess64F(v *Value, config *Config) bool { +func rewriteValueARM_OpLess64F(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -14409,9 +14267,13 @@ func rewriteValueARM_OpLess64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLess8(v *Value, config *Config) bool { +func rewriteValueARM_OpLess8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8 x y) // cond: // result: (LessThan (CMP (SignExt8to32 x) (SignExt8to32 y))) @@ -14420,19 +14282,23 @@ func rewriteValueARM_OpLess8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMLessThan) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpLess8U(v *Value, config *Config) bool { +func rewriteValueARM_OpLess8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8U x y) // cond: // result: (LessThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -14441,19 +14307,17 @@ func rewriteValueARM_OpLess8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMLessThanU) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpLoad(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpLoad(v *Value) bool { // match: (Load <t> ptr mem) // cond: t.IsBoolean() // result: (MOVBUload ptr mem) @@ -14576,9 +14440,13 @@ func rewriteValueARM_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpLsh16x16(v *Value, config *Config) bool { +func rewriteValueARM_OpLsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x16 x y) // cond: // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) @@ -14589,20 +14457,20 @@ func rewriteValueARM_OpLsh16x16(v *Value, config *Config) bool { v.AuxInt = 0 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags) v2.AuxInt = 256 - v3 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v3.AddArg(y) v2.AddArg(v3) v.AddArg(v2) return true } } -func rewriteValueARM_OpLsh16x32(v *Value, config *Config) bool { +func rewriteValueARM_OpLsh16x32(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 x y) @@ -14624,9 +14492,7 @@ func rewriteValueARM_OpLsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLsh16x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpLsh16x64(v *Value) bool { // match: (Lsh16x64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SLLconst x [c]) @@ -14663,9 +14529,13 @@ func rewriteValueARM_OpLsh16x64(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpLsh16x8(v *Value, config *Config) bool { +func rewriteValueARM_OpLsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x8 x y) // cond: // result: (SLL x (ZeroExt8to32 y)) @@ -14674,15 +14544,19 @@ func rewriteValueARM_OpLsh16x8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMSLL) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueARM_OpLsh32x16(v *Value, config *Config) bool { +func rewriteValueARM_OpLsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x16 x y) // cond: // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) @@ -14693,20 +14567,20 @@ func rewriteValueARM_OpLsh32x16(v *Value, config *Config) bool { v.AuxInt = 0 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags) v2.AuxInt = 256 - v3 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v3.AddArg(y) v2.AddArg(v3) v.AddArg(v2) return true } } -func rewriteValueARM_OpLsh32x32(v *Value, config *Config) bool { +func rewriteValueARM_OpLsh32x32(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 x y) @@ -14728,9 +14602,7 @@ func rewriteValueARM_OpLsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLsh32x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpLsh32x64(v *Value) bool { // match: (Lsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SLLconst x [c]) @@ -14767,9 +14639,13 @@ func rewriteValueARM_OpLsh32x64(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpLsh32x8(v *Value, config *Config) bool { +func rewriteValueARM_OpLsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x8 x y) // cond: // result: (SLL x (ZeroExt8to32 y)) @@ -14778,15 +14654,19 @@ func rewriteValueARM_OpLsh32x8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMSLL) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueARM_OpLsh8x16(v *Value, config *Config) bool { +func rewriteValueARM_OpLsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x16 x y) // cond: // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) @@ -14797,20 +14677,20 @@ func rewriteValueARM_OpLsh8x16(v *Value, config *Config) bool { v.AuxInt = 0 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags) v2.AuxInt = 256 - v3 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v3.AddArg(y) v2.AddArg(v3) v.AddArg(v2) return true } } -func rewriteValueARM_OpLsh8x32(v *Value, config *Config) bool { +func rewriteValueARM_OpLsh8x32(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 x y) @@ -14832,9 +14712,7 @@ func rewriteValueARM_OpLsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpLsh8x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpLsh8x64(v *Value) bool { // match: (Lsh8x64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SLLconst x [c]) @@ -14871,9 +14749,13 @@ func rewriteValueARM_OpLsh8x64(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpLsh8x8(v *Value, config *Config) bool { +func rewriteValueARM_OpLsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x8 x y) // cond: // result: (SLL x (ZeroExt8to32 y)) @@ -14882,15 +14764,19 @@ func rewriteValueARM_OpLsh8x8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMSLL) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueARM_OpMod16(v *Value, config *Config) bool { +func rewriteValueARM_OpMod16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16 x y) // cond: // result: (Mod32 (SignExt16to32 x) (SignExt16to32 y)) @@ -14898,18 +14784,22 @@ func rewriteValueARM_OpMod16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMod32) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpMod16u(v *Value, config *Config) bool { +func rewriteValueARM_OpMod16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16u x y) // cond: // result: (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y)) @@ -14917,75 +14807,83 @@ func rewriteValueARM_OpMod16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMod32u) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpMod32(v *Value, config *Config) bool { +func rewriteValueARM_OpMod32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32 x y) // cond: - // result: (SUB (XOR <config.fe.TypeUInt32()> (Select1 <config.fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (SUB <config.fe.TypeUInt32()> (XOR <config.fe.TypeUInt32()> x (Signmask x)) (Signmask x)) (SUB <config.fe.TypeUInt32()> (XOR <config.fe.TypeUInt32()> y (Signmask y)) (Signmask y)))) (Signmask x)) (Signmask x)) + // result: (SUB (XOR <fe.TypeUInt32()> (Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> x (Signmask x)) (Signmask x)) (SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> y (Signmask y)) (Signmask y)))) (Signmask x)) (Signmask x)) for { x := v.Args[0] y := v.Args[1] v.reset(OpARMSUB) - v0 := b.NewValue0(v.Pos, OpARMXOR, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpSelect1, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) + v0 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpSelect1, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v2.Aux = config.ctxt.Lookup("udiv", 0) - v3 := b.NewValue0(v.Pos, OpARMSUB, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpARMXOR, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpARMSUB, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32()) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v5 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v5.AddArg(x) v4.AddArg(v5) v3.AddArg(v4) - v6 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v6 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v6.AddArg(x) v3.AddArg(v6) v2.AddArg(v3) - v7 := b.NewValue0(v.Pos, OpARMSUB, config.fe.TypeUInt32()) - v8 := b.NewValue0(v.Pos, OpARMXOR, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpARMSUB, fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32()) v8.AddArg(y) - v9 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v9 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v9.AddArg(y) v8.AddArg(v9) v7.AddArg(v8) - v10 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v10 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v10.AddArg(y) v7.AddArg(v10) v2.AddArg(v7) v1.AddArg(v2) v0.AddArg(v1) - v11 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v11 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v11.AddArg(x) v0.AddArg(v11) v.AddArg(v0) - v12 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v12 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v12.AddArg(x) v.AddArg(v12) return true } } -func rewriteValueARM_OpMod32u(v *Value, config *Config) bool { +func rewriteValueARM_OpMod32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32u x y) // cond: - // result: (Select1 <config.fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) + // result: (Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) for { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v.Type = config.fe.TypeUInt32() - v0 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) + v.Type = fe.TypeUInt32() + v0 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v0.Aux = config.ctxt.Lookup("udiv", 0) v0.AddArg(x) v0.AddArg(y) @@ -14993,9 +14891,13 @@ func rewriteValueARM_OpMod32u(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpMod8(v *Value, config *Config) bool { +func rewriteValueARM_OpMod8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8 x y) // cond: // result: (Mod32 (SignExt8to32 x) (SignExt8to32 y)) @@ -15003,18 +14905,22 @@ func rewriteValueARM_OpMod8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMod32) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpMod8u(v *Value, config *Config) bool { +func rewriteValueARM_OpMod8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8u x y) // cond: // result: (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y)) @@ -15022,18 +14928,22 @@ func rewriteValueARM_OpMod8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMod32u) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpMove(v *Value, config *Config) bool { +func rewriteValueARM_OpMove(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Move [0] _ _ mem) // cond: // result: mem @@ -15059,7 +14969,7 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpARMMOVBstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -15082,7 +14992,7 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { } v.reset(OpARMMOVHstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARMMOVHUload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpARMMOVHUload, fe.TypeUInt16()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -15102,14 +15012,14 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { v.reset(OpARMMOVBstore) v.AuxInt = 1 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v0.AuxInt = 1 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v2 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -15133,7 +15043,7 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { } v.reset(OpARMMOVWstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARMMOVWload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMMOVWload, fe.TypeUInt32()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -15157,14 +15067,14 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { v.reset(OpARMMOVHstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARMMOVHUload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpARMMOVHUload, fe.TypeUInt16()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARMMOVHstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARMMOVHUload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpARMMOVHUload, fe.TypeUInt16()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -15185,7 +15095,7 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { v.reset(OpARMMOVBstore) v.AuxInt = 3 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v0.AuxInt = 3 v0.AddArg(src) v0.AddArg(mem) @@ -15193,7 +15103,7 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v1.AuxInt = 2 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v2 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v2.AuxInt = 2 v2.AddArg(src) v2.AddArg(mem) @@ -15201,14 +15111,14 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v3.AuxInt = 1 v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v4 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v4.AuxInt = 1 v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v5.AddArg(dst) - v6 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v6 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v6.AddArg(src) v6.AddArg(mem) v5.AddArg(v6) @@ -15231,7 +15141,7 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { v.reset(OpARMMOVBstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) @@ -15239,14 +15149,14 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v1.AuxInt = 1 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v2 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v2.AuxInt = 1 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8()) + v4 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -15299,9 +15209,7 @@ func rewriteValueARM_OpMove(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpMul16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpMul16(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MUL x y) @@ -15314,9 +15222,7 @@ func rewriteValueARM_OpMul16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpMul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpMul32(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MUL x y) @@ -15329,9 +15235,7 @@ func rewriteValueARM_OpMul32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpMul32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpMul32F(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULF x y) @@ -15344,9 +15248,7 @@ func rewriteValueARM_OpMul32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpMul32uhilo(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpMul32uhilo(v *Value) bool { // match: (Mul32uhilo x y) // cond: // result: (MULLU x y) @@ -15359,9 +15261,7 @@ func rewriteValueARM_OpMul32uhilo(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpMul64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpMul64F(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULD x y) @@ -15374,9 +15274,7 @@ func rewriteValueARM_OpMul64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpMul8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpMul8(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MUL x y) @@ -15389,9 +15287,7 @@ func rewriteValueARM_OpMul8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeg16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpNeg16(v *Value) bool { // match: (Neg16 x) // cond: // result: (RSBconst [0] x) @@ -15403,9 +15299,7 @@ func rewriteValueARM_OpNeg16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeg32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpNeg32(v *Value) bool { // match: (Neg32 x) // cond: // result: (RSBconst [0] x) @@ -15417,9 +15311,7 @@ func rewriteValueARM_OpNeg32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeg32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpNeg32F(v *Value) bool { // match: (Neg32F x) // cond: // result: (NEGF x) @@ -15430,9 +15322,7 @@ func rewriteValueARM_OpNeg32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeg64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpNeg64F(v *Value) bool { // match: (Neg64F x) // cond: // result: (NEGD x) @@ -15443,9 +15333,7 @@ func rewriteValueARM_OpNeg64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeg8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpNeg8(v *Value) bool { // match: (Neg8 x) // cond: // result: (RSBconst [0] x) @@ -15457,9 +15345,13 @@ func rewriteValueARM_OpNeg8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeq16(v *Value, config *Config) bool { +func rewriteValueARM_OpNeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq16 x y) // cond: // result: (NotEqual (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -15468,17 +15360,17 @@ func rewriteValueARM_OpNeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMNotEqual) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpNeq32(v *Value, config *Config) bool { +func rewriteValueARM_OpNeq32(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -15495,7 +15387,7 @@ func rewriteValueARM_OpNeq32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeq32F(v *Value, config *Config) bool { +func rewriteValueARM_OpNeq32F(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -15512,7 +15404,7 @@ func rewriteValueARM_OpNeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeq64F(v *Value, config *Config) bool { +func rewriteValueARM_OpNeq64F(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -15529,9 +15421,13 @@ func rewriteValueARM_OpNeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeq8(v *Value, config *Config) bool { +func rewriteValueARM_OpNeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq8 x y) // cond: // result: (NotEqual (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -15540,19 +15436,17 @@ func rewriteValueARM_OpNeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMNotEqual) v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM_OpNeqB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpNeqB(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -15565,7 +15459,7 @@ func rewriteValueARM_OpNeqB(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNeqPtr(v *Value, config *Config) bool { +func rewriteValueARM_OpNeqPtr(v *Value) bool { b := v.Block _ = b // match: (NeqPtr x y) @@ -15582,9 +15476,7 @@ func rewriteValueARM_OpNeqPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNilCheck(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpNilCheck(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -15597,9 +15489,7 @@ func rewriteValueARM_OpNilCheck(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpNot(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpNot(v *Value) bool { // match: (Not x) // cond: // result: (XORconst [1] x) @@ -15611,9 +15501,7 @@ func rewriteValueARM_OpNot(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpOffPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpOffPtr(v *Value) bool { // match: (OffPtr [off] ptr:(SP)) // cond: // result: (MOVWaddr [off] ptr) @@ -15640,9 +15528,7 @@ func rewriteValueARM_OpOffPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpOr16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpOr16(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -15655,9 +15541,7 @@ func rewriteValueARM_OpOr16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpOr32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpOr32(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -15670,9 +15554,7 @@ func rewriteValueARM_OpOr32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpOr8(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -15685,9 +15567,7 @@ func rewriteValueARM_OpOr8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpOrB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpOrB(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -15700,9 +15580,7 @@ func rewriteValueARM_OpOrB(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpRound32F(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -15714,9 +15592,7 @@ func rewriteValueARM_OpRound32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpRound64F(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -15728,9 +15604,13 @@ func rewriteValueARM_OpRound64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpRsh16Ux16(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh16Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux16 x y) // cond: // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) @@ -15740,25 +15620,29 @@ func rewriteValueARM_OpRsh16Ux16(v *Value, config *Config) bool { v.reset(OpARMCMOVWHSconst) v.AuxInt = 0 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) v3 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags) v3.AuxInt = 256 - v4 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM_OpRsh16Ux32(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh16Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux32 x y) // cond: // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) y) (CMPconst [256] y) [0]) @@ -15768,7 +15652,7 @@ func rewriteValueARM_OpRsh16Ux32(v *Value, config *Config) bool { v.reset(OpARMCMOVWHSconst) v.AuxInt = 0 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -15780,12 +15664,16 @@ func rewriteValueARM_OpRsh16Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpRsh16Ux64(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh16Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux64 x (Const64 [c])) // cond: uint64(c) < 16 - // result: (SRLconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) + // result: (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) for { x := v.Args[0] v_1 := v.Args[1] @@ -15798,7 +15686,7 @@ func rewriteValueARM_OpRsh16Ux64(v *Value, config *Config) bool { } v.reset(OpARMSRLconst) v.AuxInt = c + 16 - v0 := b.NewValue0(v.Pos, OpARMSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32()) v0.AuxInt = 16 v0.AddArg(x) v.AddArg(v0) @@ -15822,9 +15710,13 @@ func rewriteValueARM_OpRsh16Ux64(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpRsh16Ux8(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh16Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux8 x y) // cond: // result: (SRL (ZeroExt16to32 x) (ZeroExt8to32 y)) @@ -15832,18 +15724,22 @@ func rewriteValueARM_OpRsh16Ux8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARMSRL) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpRsh16x16(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x16 x y) // cond: // result: (SRAcond (SignExt16to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) @@ -15851,24 +15747,28 @@ func rewriteValueARM_OpRsh16x16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARMSRAcond) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags) v2.AuxInt = 256 - v3 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v3.AddArg(y) v2.AddArg(v3) v.AddArg(v2) return true } } -func rewriteValueARM_OpRsh16x32(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x32 x y) // cond: // result: (SRAcond (SignExt16to32 x) y (CMPconst [256] y)) @@ -15876,7 +15776,7 @@ func rewriteValueARM_OpRsh16x32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARMSRAcond) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) v.AddArg(y) @@ -15887,12 +15787,16 @@ func rewriteValueARM_OpRsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpRsh16x64(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x64 x (Const64 [c])) // cond: uint64(c) < 16 - // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) + // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) for { x := v.Args[0] v_1 := v.Args[1] @@ -15905,7 +15809,7 @@ func rewriteValueARM_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpARMSRAconst) v.AuxInt = c + 16 - v0 := b.NewValue0(v.Pos, OpARMSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32()) v0.AuxInt = 16 v0.AddArg(x) v.AddArg(v0) @@ -15913,7 +15817,7 @@ func rewriteValueARM_OpRsh16x64(v *Value, config *Config) bool { } // match: (Rsh16x64 x (Const64 [c])) // cond: uint64(c) >= 16 - // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [31]) + // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31]) for { x := v.Args[0] v_1 := v.Args[1] @@ -15926,7 +15830,7 @@ func rewriteValueARM_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpARMSRAconst) v.AuxInt = 31 - v0 := b.NewValue0(v.Pos, OpARMSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32()) v0.AuxInt = 16 v0.AddArg(x) v.AddArg(v0) @@ -15934,9 +15838,13 @@ func rewriteValueARM_OpRsh16x64(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpRsh16x8(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x8 x y) // cond: // result: (SRA (SignExt16to32 x) (ZeroExt8to32 y)) @@ -15944,18 +15852,22 @@ func rewriteValueARM_OpRsh16x8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARMSRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpRsh32Ux16(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh32Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux16 x y) // cond: // result: (CMOVWHSconst (SRL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) @@ -15966,20 +15878,20 @@ func rewriteValueARM_OpRsh32Ux16(v *Value, config *Config) bool { v.AuxInt = 0 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags) v2.AuxInt = 256 - v3 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v3.AddArg(y) v2.AddArg(v3) v.AddArg(v2) return true } } -func rewriteValueARM_OpRsh32Ux32(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh32Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 x y) @@ -16001,9 +15913,7 @@ func rewriteValueARM_OpRsh32Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpRsh32Ux64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpRsh32Ux64(v *Value) bool { // match: (Rsh32Ux64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SRLconst x [c]) @@ -16040,9 +15950,13 @@ func rewriteValueARM_OpRsh32Ux64(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpRsh32Ux8(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh32Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux8 x y) // cond: // result: (SRL x (ZeroExt8to32 y)) @@ -16051,15 +15965,19 @@ func rewriteValueARM_OpRsh32Ux8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMSRL) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueARM_OpRsh32x16(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x16 x y) // cond: // result: (SRAcond x (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) @@ -16068,19 +15986,19 @@ func rewriteValueARM_OpRsh32x16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMSRAcond) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(y) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags) v1.AuxInt = 256 - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) return true } } -func rewriteValueARM_OpRsh32x32(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh32x32(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 x y) @@ -16099,9 +16017,7 @@ func rewriteValueARM_OpRsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpRsh32x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpRsh32x64(v *Value) bool { // match: (Rsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SRAconst x [c]) @@ -16140,9 +16056,13 @@ func rewriteValueARM_OpRsh32x64(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpRsh32x8(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x8 x y) // cond: // result: (SRA x (ZeroExt8to32 y)) @@ -16151,15 +16071,19 @@ func rewriteValueARM_OpRsh32x8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARMSRA) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueARM_OpRsh8Ux16(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh8Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux16 x y) // cond: // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) @@ -16169,25 +16093,29 @@ func rewriteValueARM_OpRsh8Ux16(v *Value, config *Config) bool { v.reset(OpARMCMOVWHSconst) v.AuxInt = 0 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) v3 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags) v3.AuxInt = 256 - v4 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM_OpRsh8Ux32(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh8Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux32 x y) // cond: // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) y) (CMPconst [256] y) [0]) @@ -16197,7 +16125,7 @@ func rewriteValueARM_OpRsh8Ux32(v *Value, config *Config) bool { v.reset(OpARMCMOVWHSconst) v.AuxInt = 0 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -16209,12 +16137,16 @@ func rewriteValueARM_OpRsh8Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpRsh8Ux64(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh8Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux64 x (Const64 [c])) // cond: uint64(c) < 8 - // result: (SRLconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) + // result: (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) for { x := v.Args[0] v_1 := v.Args[1] @@ -16227,7 +16159,7 @@ func rewriteValueARM_OpRsh8Ux64(v *Value, config *Config) bool { } v.reset(OpARMSRLconst) v.AuxInt = c + 24 - v0 := b.NewValue0(v.Pos, OpARMSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32()) v0.AuxInt = 24 v0.AddArg(x) v.AddArg(v0) @@ -16251,9 +16183,13 @@ func rewriteValueARM_OpRsh8Ux64(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpRsh8Ux8(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh8Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux8 x y) // cond: // result: (SRL (ZeroExt8to32 x) (ZeroExt8to32 y)) @@ -16261,18 +16197,22 @@ func rewriteValueARM_OpRsh8Ux8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARMSRL) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpRsh8x16(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x16 x y) // cond: // result: (SRAcond (SignExt8to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) @@ -16280,24 +16220,28 @@ func rewriteValueARM_OpRsh8x16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARMSRAcond) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags) v2.AuxInt = 256 - v3 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v3.AddArg(y) v2.AddArg(v3) v.AddArg(v2) return true } } -func rewriteValueARM_OpRsh8x32(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x32 x y) // cond: // result: (SRAcond (SignExt8to32 x) y (CMPconst [256] y)) @@ -16305,7 +16249,7 @@ func rewriteValueARM_OpRsh8x32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARMSRAcond) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) v.AddArg(y) @@ -16316,12 +16260,16 @@ func rewriteValueARM_OpRsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpRsh8x64(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x64 x (Const64 [c])) // cond: uint64(c) < 8 - // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) + // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) for { x := v.Args[0] v_1 := v.Args[1] @@ -16334,7 +16282,7 @@ func rewriteValueARM_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpARMSRAconst) v.AuxInt = c + 24 - v0 := b.NewValue0(v.Pos, OpARMSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32()) v0.AuxInt = 24 v0.AddArg(x) v.AddArg(v0) @@ -16342,7 +16290,7 @@ func rewriteValueARM_OpRsh8x64(v *Value, config *Config) bool { } // match: (Rsh8x64 x (Const64 [c])) // cond: uint64(c) >= 8 - // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [31]) + // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31]) for { x := v.Args[0] v_1 := v.Args[1] @@ -16355,7 +16303,7 @@ func rewriteValueARM_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpARMSRAconst) v.AuxInt = 31 - v0 := b.NewValue0(v.Pos, OpARMSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32()) v0.AuxInt = 24 v0.AddArg(x) v.AddArg(v0) @@ -16363,9 +16311,13 @@ func rewriteValueARM_OpRsh8x64(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpRsh8x8(v *Value, config *Config) bool { +func rewriteValueARM_OpRsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x8 x y) // cond: // result: (SRA (SignExt8to32 x) (ZeroExt8to32 y)) @@ -16373,18 +16325,16 @@ func rewriteValueARM_OpRsh8x8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARMSRA) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM_OpSelect0(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSelect0(v *Value) bool { // match: (Select0 (CALLudiv x (MOVWconst [1]))) // cond: // result: x @@ -16452,9 +16402,7 @@ func rewriteValueARM_OpSelect0(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpSelect1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSelect1(v *Value) bool { // match: (Select1 (CALLudiv _ (MOVWconst [1]))) // cond: // result: (MOVWconst [0]) @@ -16520,9 +16468,7 @@ func rewriteValueARM_OpSelect1(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpSignExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSignExt16to32(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -16533,9 +16479,7 @@ func rewriteValueARM_OpSignExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSignExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSignExt8to16(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -16546,9 +16490,7 @@ func rewriteValueARM_OpSignExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSignExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSignExt8to32(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -16559,9 +16501,7 @@ func rewriteValueARM_OpSignExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSignmask(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSignmask(v *Value) bool { // match: (Signmask x) // cond: // result: (SRAconst x [31]) @@ -16573,7 +16513,7 @@ func rewriteValueARM_OpSignmask(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSlicemask(v *Value, config *Config) bool { +func rewriteValueARM_OpSlicemask(v *Value) bool { b := v.Block _ = b // match: (Slicemask <t> x) @@ -16591,9 +16531,7 @@ func rewriteValueARM_OpSlicemask(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSqrt(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSqrt(v *Value) bool { // match: (Sqrt x) // cond: // result: (SQRTD x) @@ -16604,9 +16542,7 @@ func rewriteValueARM_OpSqrt(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpStaticCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpStaticCall(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -16621,9 +16557,7 @@ func rewriteValueARM_OpStaticCall(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpStore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpStore(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 1 // result: (MOVBstore ptr val mem) @@ -16711,9 +16645,7 @@ func rewriteValueARM_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpSub16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSub16(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUB x y) @@ -16726,9 +16658,7 @@ func rewriteValueARM_OpSub16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSub32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSub32(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUB x y) @@ -16741,9 +16671,7 @@ func rewriteValueARM_OpSub32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSub32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSub32F(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBF x y) @@ -16756,9 +16684,7 @@ func rewriteValueARM_OpSub32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSub32carry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSub32carry(v *Value) bool { // match: (Sub32carry x y) // cond: // result: (SUBS x y) @@ -16771,9 +16697,7 @@ func rewriteValueARM_OpSub32carry(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSub32withcarry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSub32withcarry(v *Value) bool { // match: (Sub32withcarry x y c) // cond: // result: (SBC x y c) @@ -16788,9 +16712,7 @@ func rewriteValueARM_OpSub32withcarry(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSub64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSub64F(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBD x y) @@ -16803,9 +16725,7 @@ func rewriteValueARM_OpSub64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSub8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSub8(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUB x y) @@ -16818,9 +16738,7 @@ func rewriteValueARM_OpSub8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpSubPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpSubPtr(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -16833,9 +16751,7 @@ func rewriteValueARM_OpSubPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpTrunc16to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpTrunc16to8(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -16847,9 +16763,7 @@ func rewriteValueARM_OpTrunc16to8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpTrunc32to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpTrunc32to16(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -16861,9 +16775,7 @@ func rewriteValueARM_OpTrunc32to16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpTrunc32to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpTrunc32to8(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -16875,9 +16787,7 @@ func rewriteValueARM_OpTrunc32to8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpXor16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpXor16(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -16890,9 +16800,7 @@ func rewriteValueARM_OpXor16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpXor32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpXor32(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -16905,9 +16813,7 @@ func rewriteValueARM_OpXor32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpXor8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpXor8(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -16920,9 +16826,13 @@ func rewriteValueARM_OpXor8(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpZero(v *Value, config *Config) bool { +func rewriteValueARM_OpZero(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Zero [0] _ mem) // cond: // result: mem @@ -16947,7 +16857,7 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { mem := v.Args[1] v.reset(OpARMMOVBstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -16968,7 +16878,7 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { } v.reset(OpARMMOVHstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -16986,13 +16896,13 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { v.reset(OpARMMOVBstore) v.AuxInt = 1 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v1.AuxInt = 0 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -17014,7 +16924,7 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { } v.reset(OpARMMOVWstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -17036,13 +16946,13 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { v.reset(OpARMMOVHstore) v.AuxInt = 2 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARMMOVHstore, TypeMem) v1.AuxInt = 0 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -17061,25 +16971,25 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { v.reset(OpARMMOVBstore) v.AuxInt = 3 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v1.AuxInt = 2 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v3.AuxInt = 1 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v4.AuxInt = 0 v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v5.AuxInt = 0 v5.AddArg(ptr) - v6 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v6.AuxInt = 0 v5.AddArg(v6) v5.AddArg(mem) @@ -17100,19 +17010,19 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { v.reset(OpARMMOVBstore) v.AuxInt = 2 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v1.AuxInt = 1 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem) v3.AuxInt = 0 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -17134,7 +17044,7 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { v.reset(OpARMDUFFZERO) v.AuxInt = 4 * (128 - int64(s/4)) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -17158,7 +17068,7 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { v0.AuxInt = s - moveSize(t.(Type).Alignment(), config) v0.AddArg(ptr) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32()) v1.AuxInt = 0 v.AddArg(v1) v.AddArg(mem) @@ -17166,9 +17076,7 @@ func rewriteValueARM_OpZero(v *Value, config *Config) bool { } return false } -func rewriteValueARM_OpZeroExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpZeroExt16to32(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHUreg x) @@ -17179,9 +17087,7 @@ func rewriteValueARM_OpZeroExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpZeroExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpZeroExt8to16(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBUreg x) @@ -17192,9 +17098,7 @@ func rewriteValueARM_OpZeroExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpZeroExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM_OpZeroExt8to32(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBUreg x) @@ -17205,17 +17109,21 @@ func rewriteValueARM_OpZeroExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueARM_OpZeromask(v *Value, config *Config) bool { +func rewriteValueARM_OpZeromask(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Zeromask x) // cond: - // result: (SRAconst (RSBshiftRL <config.fe.TypeInt32()> x x [1]) [31]) + // result: (SRAconst (RSBshiftRL <fe.TypeInt32()> x x [1]) [31]) for { x := v.Args[0] v.reset(OpARMSRAconst) v.AuxInt = 31 - v0 := b.NewValue0(v.Pos, OpARMRSBshiftRL, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpARMRSBshiftRL, fe.TypeInt32()) v0.AuxInt = 1 v0.AddArg(x) v0.AddArg(x) @@ -17223,7 +17131,11 @@ func rewriteValueARM_OpZeromask(v *Value, config *Config) bool { return true } } -func rewriteBlockARM(b *Block, config *Config) bool { +func rewriteBlockARM(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { case BlockARMEQ: // match: (EQ (FlagEQ) yes no) diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go index cb48e664fe..67604f741c 100644 --- a/src/cmd/compile/internal/ssa/rewriteARM64.go +++ b/src/cmd/compile/internal/ssa/rewriteARM64.go @@ -6,716 +6,714 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValueARM64(v *Value, config *Config) bool { +func rewriteValueARM64(v *Value) bool { switch v.Op { case OpARM64ADD: - return rewriteValueARM64_OpARM64ADD(v, config) + return rewriteValueARM64_OpARM64ADD(v) case OpARM64ADDconst: - return rewriteValueARM64_OpARM64ADDconst(v, config) + return rewriteValueARM64_OpARM64ADDconst(v) case OpARM64ADDshiftLL: - return rewriteValueARM64_OpARM64ADDshiftLL(v, config) + return rewriteValueARM64_OpARM64ADDshiftLL(v) case OpARM64ADDshiftRA: - return rewriteValueARM64_OpARM64ADDshiftRA(v, config) + return rewriteValueARM64_OpARM64ADDshiftRA(v) case OpARM64ADDshiftRL: - return rewriteValueARM64_OpARM64ADDshiftRL(v, config) + return rewriteValueARM64_OpARM64ADDshiftRL(v) case OpARM64AND: - return rewriteValueARM64_OpARM64AND(v, config) + return rewriteValueARM64_OpARM64AND(v) case OpARM64ANDconst: - return rewriteValueARM64_OpARM64ANDconst(v, config) + return rewriteValueARM64_OpARM64ANDconst(v) case OpARM64ANDshiftLL: - return rewriteValueARM64_OpARM64ANDshiftLL(v, config) + return rewriteValueARM64_OpARM64ANDshiftLL(v) case OpARM64ANDshiftRA: - return rewriteValueARM64_OpARM64ANDshiftRA(v, config) + return rewriteValueARM64_OpARM64ANDshiftRA(v) case OpARM64ANDshiftRL: - return rewriteValueARM64_OpARM64ANDshiftRL(v, config) + return rewriteValueARM64_OpARM64ANDshiftRL(v) case OpARM64BIC: - return rewriteValueARM64_OpARM64BIC(v, config) + return rewriteValueARM64_OpARM64BIC(v) case OpARM64BICconst: - return rewriteValueARM64_OpARM64BICconst(v, config) + return rewriteValueARM64_OpARM64BICconst(v) case OpARM64BICshiftLL: - return rewriteValueARM64_OpARM64BICshiftLL(v, config) + return rewriteValueARM64_OpARM64BICshiftLL(v) case OpARM64BICshiftRA: - return rewriteValueARM64_OpARM64BICshiftRA(v, config) + return rewriteValueARM64_OpARM64BICshiftRA(v) case OpARM64BICshiftRL: - return rewriteValueARM64_OpARM64BICshiftRL(v, config) + return rewriteValueARM64_OpARM64BICshiftRL(v) case OpARM64CMP: - return rewriteValueARM64_OpARM64CMP(v, config) + return rewriteValueARM64_OpARM64CMP(v) case OpARM64CMPW: - return rewriteValueARM64_OpARM64CMPW(v, config) + return rewriteValueARM64_OpARM64CMPW(v) case OpARM64CMPWconst: - return rewriteValueARM64_OpARM64CMPWconst(v, config) + return rewriteValueARM64_OpARM64CMPWconst(v) case OpARM64CMPconst: - return rewriteValueARM64_OpARM64CMPconst(v, config) + return rewriteValueARM64_OpARM64CMPconst(v) case OpARM64CMPshiftLL: - return rewriteValueARM64_OpARM64CMPshiftLL(v, config) + return rewriteValueARM64_OpARM64CMPshiftLL(v) case OpARM64CMPshiftRA: - return rewriteValueARM64_OpARM64CMPshiftRA(v, config) + return rewriteValueARM64_OpARM64CMPshiftRA(v) case OpARM64CMPshiftRL: - return rewriteValueARM64_OpARM64CMPshiftRL(v, config) + return rewriteValueARM64_OpARM64CMPshiftRL(v) case OpARM64CSELULT: - return rewriteValueARM64_OpARM64CSELULT(v, config) + return rewriteValueARM64_OpARM64CSELULT(v) case OpARM64CSELULT0: - return rewriteValueARM64_OpARM64CSELULT0(v, config) + return rewriteValueARM64_OpARM64CSELULT0(v) case OpARM64DIV: - return rewriteValueARM64_OpARM64DIV(v, config) + return rewriteValueARM64_OpARM64DIV(v) case OpARM64DIVW: - return rewriteValueARM64_OpARM64DIVW(v, config) + return rewriteValueARM64_OpARM64DIVW(v) case OpARM64Equal: - return rewriteValueARM64_OpARM64Equal(v, config) + return rewriteValueARM64_OpARM64Equal(v) case OpARM64FMOVDload: - return rewriteValueARM64_OpARM64FMOVDload(v, config) + return rewriteValueARM64_OpARM64FMOVDload(v) case OpARM64FMOVDstore: - return rewriteValueARM64_OpARM64FMOVDstore(v, config) + return rewriteValueARM64_OpARM64FMOVDstore(v) case OpARM64FMOVSload: - return rewriteValueARM64_OpARM64FMOVSload(v, config) + return rewriteValueARM64_OpARM64FMOVSload(v) case OpARM64FMOVSstore: - return rewriteValueARM64_OpARM64FMOVSstore(v, config) + return rewriteValueARM64_OpARM64FMOVSstore(v) case OpARM64GreaterEqual: - return rewriteValueARM64_OpARM64GreaterEqual(v, config) + return rewriteValueARM64_OpARM64GreaterEqual(v) case OpARM64GreaterEqualU: - return rewriteValueARM64_OpARM64GreaterEqualU(v, config) + return rewriteValueARM64_OpARM64GreaterEqualU(v) case OpARM64GreaterThan: - return rewriteValueARM64_OpARM64GreaterThan(v, config) + return rewriteValueARM64_OpARM64GreaterThan(v) case OpARM64GreaterThanU: - return rewriteValueARM64_OpARM64GreaterThanU(v, config) + return rewriteValueARM64_OpARM64GreaterThanU(v) case OpARM64LessEqual: - return rewriteValueARM64_OpARM64LessEqual(v, config) + return rewriteValueARM64_OpARM64LessEqual(v) case OpARM64LessEqualU: - return rewriteValueARM64_OpARM64LessEqualU(v, config) + return rewriteValueARM64_OpARM64LessEqualU(v) case OpARM64LessThan: - return rewriteValueARM64_OpARM64LessThan(v, config) + return rewriteValueARM64_OpARM64LessThan(v) case OpARM64LessThanU: - return rewriteValueARM64_OpARM64LessThanU(v, config) + return rewriteValueARM64_OpARM64LessThanU(v) case OpARM64MOD: - return rewriteValueARM64_OpARM64MOD(v, config) + return rewriteValueARM64_OpARM64MOD(v) case OpARM64MODW: - return rewriteValueARM64_OpARM64MODW(v, config) + return rewriteValueARM64_OpARM64MODW(v) case OpARM64MOVBUload: - return rewriteValueARM64_OpARM64MOVBUload(v, config) + return rewriteValueARM64_OpARM64MOVBUload(v) case OpARM64MOVBUreg: - return rewriteValueARM64_OpARM64MOVBUreg(v, config) + return rewriteValueARM64_OpARM64MOVBUreg(v) case OpARM64MOVBload: - return rewriteValueARM64_OpARM64MOVBload(v, config) + return rewriteValueARM64_OpARM64MOVBload(v) case OpARM64MOVBreg: - return rewriteValueARM64_OpARM64MOVBreg(v, config) + return rewriteValueARM64_OpARM64MOVBreg(v) case OpARM64MOVBstore: - return rewriteValueARM64_OpARM64MOVBstore(v, config) + return rewriteValueARM64_OpARM64MOVBstore(v) case OpARM64MOVBstorezero: - return rewriteValueARM64_OpARM64MOVBstorezero(v, config) + return rewriteValueARM64_OpARM64MOVBstorezero(v) case OpARM64MOVDload: - return rewriteValueARM64_OpARM64MOVDload(v, config) + return rewriteValueARM64_OpARM64MOVDload(v) case OpARM64MOVDreg: - return rewriteValueARM64_OpARM64MOVDreg(v, config) + return rewriteValueARM64_OpARM64MOVDreg(v) case OpARM64MOVDstore: - return rewriteValueARM64_OpARM64MOVDstore(v, config) + return rewriteValueARM64_OpARM64MOVDstore(v) case OpARM64MOVDstorezero: - return rewriteValueARM64_OpARM64MOVDstorezero(v, config) + return rewriteValueARM64_OpARM64MOVDstorezero(v) case OpARM64MOVHUload: - return rewriteValueARM64_OpARM64MOVHUload(v, config) + return rewriteValueARM64_OpARM64MOVHUload(v) case OpARM64MOVHUreg: - return rewriteValueARM64_OpARM64MOVHUreg(v, config) + return rewriteValueARM64_OpARM64MOVHUreg(v) case OpARM64MOVHload: - return rewriteValueARM64_OpARM64MOVHload(v, config) + return rewriteValueARM64_OpARM64MOVHload(v) case OpARM64MOVHreg: - return rewriteValueARM64_OpARM64MOVHreg(v, config) + return rewriteValueARM64_OpARM64MOVHreg(v) case OpARM64MOVHstore: - return rewriteValueARM64_OpARM64MOVHstore(v, config) + return rewriteValueARM64_OpARM64MOVHstore(v) case OpARM64MOVHstorezero: - return rewriteValueARM64_OpARM64MOVHstorezero(v, config) + return rewriteValueARM64_OpARM64MOVHstorezero(v) case OpARM64MOVWUload: - return rewriteValueARM64_OpARM64MOVWUload(v, config) + return rewriteValueARM64_OpARM64MOVWUload(v) case OpARM64MOVWUreg: - return rewriteValueARM64_OpARM64MOVWUreg(v, config) + return rewriteValueARM64_OpARM64MOVWUreg(v) case OpARM64MOVWload: - return rewriteValueARM64_OpARM64MOVWload(v, config) + return rewriteValueARM64_OpARM64MOVWload(v) case OpARM64MOVWreg: - return rewriteValueARM64_OpARM64MOVWreg(v, config) + return rewriteValueARM64_OpARM64MOVWreg(v) case OpARM64MOVWstore: - return rewriteValueARM64_OpARM64MOVWstore(v, config) + return rewriteValueARM64_OpARM64MOVWstore(v) case OpARM64MOVWstorezero: - return rewriteValueARM64_OpARM64MOVWstorezero(v, config) + return rewriteValueARM64_OpARM64MOVWstorezero(v) case OpARM64MUL: - return rewriteValueARM64_OpARM64MUL(v, config) + return rewriteValueARM64_OpARM64MUL(v) case OpARM64MULW: - return rewriteValueARM64_OpARM64MULW(v, config) + return rewriteValueARM64_OpARM64MULW(v) case OpARM64MVN: - return rewriteValueARM64_OpARM64MVN(v, config) + return rewriteValueARM64_OpARM64MVN(v) case OpARM64NEG: - return rewriteValueARM64_OpARM64NEG(v, config) + return rewriteValueARM64_OpARM64NEG(v) case OpARM64NotEqual: - return rewriteValueARM64_OpARM64NotEqual(v, config) + return rewriteValueARM64_OpARM64NotEqual(v) case OpARM64OR: - return rewriteValueARM64_OpARM64OR(v, config) + return rewriteValueARM64_OpARM64OR(v) case OpARM64ORconst: - return rewriteValueARM64_OpARM64ORconst(v, config) + return rewriteValueARM64_OpARM64ORconst(v) case OpARM64ORshiftLL: - return rewriteValueARM64_OpARM64ORshiftLL(v, config) + return rewriteValueARM64_OpARM64ORshiftLL(v) case OpARM64ORshiftRA: - return rewriteValueARM64_OpARM64ORshiftRA(v, config) + return rewriteValueARM64_OpARM64ORshiftRA(v) case OpARM64ORshiftRL: - return rewriteValueARM64_OpARM64ORshiftRL(v, config) + return rewriteValueARM64_OpARM64ORshiftRL(v) case OpARM64SLL: - return rewriteValueARM64_OpARM64SLL(v, config) + return rewriteValueARM64_OpARM64SLL(v) case OpARM64SLLconst: - return rewriteValueARM64_OpARM64SLLconst(v, config) + return rewriteValueARM64_OpARM64SLLconst(v) case OpARM64SRA: - return rewriteValueARM64_OpARM64SRA(v, config) + return rewriteValueARM64_OpARM64SRA(v) case OpARM64SRAconst: - return rewriteValueARM64_OpARM64SRAconst(v, config) + return rewriteValueARM64_OpARM64SRAconst(v) case OpARM64SRL: - return rewriteValueARM64_OpARM64SRL(v, config) + return rewriteValueARM64_OpARM64SRL(v) case OpARM64SRLconst: - return rewriteValueARM64_OpARM64SRLconst(v, config) + return rewriteValueARM64_OpARM64SRLconst(v) case OpARM64SUB: - return rewriteValueARM64_OpARM64SUB(v, config) + return rewriteValueARM64_OpARM64SUB(v) case OpARM64SUBconst: - return rewriteValueARM64_OpARM64SUBconst(v, config) + return rewriteValueARM64_OpARM64SUBconst(v) case OpARM64SUBshiftLL: - return rewriteValueARM64_OpARM64SUBshiftLL(v, config) + return rewriteValueARM64_OpARM64SUBshiftLL(v) case OpARM64SUBshiftRA: - return rewriteValueARM64_OpARM64SUBshiftRA(v, config) + return rewriteValueARM64_OpARM64SUBshiftRA(v) case OpARM64SUBshiftRL: - return rewriteValueARM64_OpARM64SUBshiftRL(v, config) + return rewriteValueARM64_OpARM64SUBshiftRL(v) case OpARM64UDIV: - return rewriteValueARM64_OpARM64UDIV(v, config) + return rewriteValueARM64_OpARM64UDIV(v) case OpARM64UDIVW: - return rewriteValueARM64_OpARM64UDIVW(v, config) + return rewriteValueARM64_OpARM64UDIVW(v) case OpARM64UMOD: - return rewriteValueARM64_OpARM64UMOD(v, config) + return rewriteValueARM64_OpARM64UMOD(v) case OpARM64UMODW: - return rewriteValueARM64_OpARM64UMODW(v, config) + return rewriteValueARM64_OpARM64UMODW(v) case OpARM64XOR: - return rewriteValueARM64_OpARM64XOR(v, config) + return rewriteValueARM64_OpARM64XOR(v) case OpARM64XORconst: - return rewriteValueARM64_OpARM64XORconst(v, config) + return rewriteValueARM64_OpARM64XORconst(v) case OpARM64XORshiftLL: - return rewriteValueARM64_OpARM64XORshiftLL(v, config) + return rewriteValueARM64_OpARM64XORshiftLL(v) case OpARM64XORshiftRA: - return rewriteValueARM64_OpARM64XORshiftRA(v, config) + return rewriteValueARM64_OpARM64XORshiftRA(v) case OpARM64XORshiftRL: - return rewriteValueARM64_OpARM64XORshiftRL(v, config) + return rewriteValueARM64_OpARM64XORshiftRL(v) case OpAdd16: - return rewriteValueARM64_OpAdd16(v, config) + return rewriteValueARM64_OpAdd16(v) case OpAdd32: - return rewriteValueARM64_OpAdd32(v, config) + return rewriteValueARM64_OpAdd32(v) case OpAdd32F: - return rewriteValueARM64_OpAdd32F(v, config) + return rewriteValueARM64_OpAdd32F(v) case OpAdd64: - return rewriteValueARM64_OpAdd64(v, config) + return rewriteValueARM64_OpAdd64(v) case OpAdd64F: - return rewriteValueARM64_OpAdd64F(v, config) + return rewriteValueARM64_OpAdd64F(v) case OpAdd8: - return rewriteValueARM64_OpAdd8(v, config) + return rewriteValueARM64_OpAdd8(v) case OpAddPtr: - return rewriteValueARM64_OpAddPtr(v, config) + return rewriteValueARM64_OpAddPtr(v) case OpAddr: - return rewriteValueARM64_OpAddr(v, config) + return rewriteValueARM64_OpAddr(v) case OpAnd16: - return rewriteValueARM64_OpAnd16(v, config) + return rewriteValueARM64_OpAnd16(v) case OpAnd32: - return rewriteValueARM64_OpAnd32(v, config) + return rewriteValueARM64_OpAnd32(v) case OpAnd64: - return rewriteValueARM64_OpAnd64(v, config) + return rewriteValueARM64_OpAnd64(v) case OpAnd8: - return rewriteValueARM64_OpAnd8(v, config) + return rewriteValueARM64_OpAnd8(v) case OpAndB: - return rewriteValueARM64_OpAndB(v, config) + return rewriteValueARM64_OpAndB(v) case OpAtomicAdd32: - return rewriteValueARM64_OpAtomicAdd32(v, config) + return rewriteValueARM64_OpAtomicAdd32(v) case OpAtomicAdd64: - return rewriteValueARM64_OpAtomicAdd64(v, config) + return rewriteValueARM64_OpAtomicAdd64(v) case OpAtomicAnd8: - return rewriteValueARM64_OpAtomicAnd8(v, config) + return rewriteValueARM64_OpAtomicAnd8(v) case OpAtomicCompareAndSwap32: - return rewriteValueARM64_OpAtomicCompareAndSwap32(v, config) + return rewriteValueARM64_OpAtomicCompareAndSwap32(v) case OpAtomicCompareAndSwap64: - return rewriteValueARM64_OpAtomicCompareAndSwap64(v, config) + return rewriteValueARM64_OpAtomicCompareAndSwap64(v) case OpAtomicExchange32: - return rewriteValueARM64_OpAtomicExchange32(v, config) + return rewriteValueARM64_OpAtomicExchange32(v) case OpAtomicExchange64: - return rewriteValueARM64_OpAtomicExchange64(v, config) + return rewriteValueARM64_OpAtomicExchange64(v) case OpAtomicLoad32: - return rewriteValueARM64_OpAtomicLoad32(v, config) + return rewriteValueARM64_OpAtomicLoad32(v) case OpAtomicLoad64: - return rewriteValueARM64_OpAtomicLoad64(v, config) + return rewriteValueARM64_OpAtomicLoad64(v) case OpAtomicLoadPtr: - return rewriteValueARM64_OpAtomicLoadPtr(v, config) + return rewriteValueARM64_OpAtomicLoadPtr(v) case OpAtomicOr8: - return rewriteValueARM64_OpAtomicOr8(v, config) + return rewriteValueARM64_OpAtomicOr8(v) case OpAtomicStore32: - return rewriteValueARM64_OpAtomicStore32(v, config) + return rewriteValueARM64_OpAtomicStore32(v) case OpAtomicStore64: - return rewriteValueARM64_OpAtomicStore64(v, config) + return rewriteValueARM64_OpAtomicStore64(v) case OpAtomicStorePtrNoWB: - return rewriteValueARM64_OpAtomicStorePtrNoWB(v, config) + return rewriteValueARM64_OpAtomicStorePtrNoWB(v) case OpAvg64u: - return rewriteValueARM64_OpAvg64u(v, config) + return rewriteValueARM64_OpAvg64u(v) case OpBitLen64: - return rewriteValueARM64_OpBitLen64(v, config) + return rewriteValueARM64_OpBitLen64(v) case OpBitRev16: - return rewriteValueARM64_OpBitRev16(v, config) + return rewriteValueARM64_OpBitRev16(v) case OpBitRev32: - return rewriteValueARM64_OpBitRev32(v, config) + return rewriteValueARM64_OpBitRev32(v) case OpBitRev64: - return rewriteValueARM64_OpBitRev64(v, config) + return rewriteValueARM64_OpBitRev64(v) case OpBitRev8: - return rewriteValueARM64_OpBitRev8(v, config) + return rewriteValueARM64_OpBitRev8(v) case OpBswap32: - return rewriteValueARM64_OpBswap32(v, config) + return rewriteValueARM64_OpBswap32(v) case OpBswap64: - return rewriteValueARM64_OpBswap64(v, config) + return rewriteValueARM64_OpBswap64(v) case OpClosureCall: - return rewriteValueARM64_OpClosureCall(v, config) + return rewriteValueARM64_OpClosureCall(v) case OpCom16: - return rewriteValueARM64_OpCom16(v, config) + return rewriteValueARM64_OpCom16(v) case OpCom32: - return rewriteValueARM64_OpCom32(v, config) + return rewriteValueARM64_OpCom32(v) case OpCom64: - return rewriteValueARM64_OpCom64(v, config) + return rewriteValueARM64_OpCom64(v) case OpCom8: - return rewriteValueARM64_OpCom8(v, config) + return rewriteValueARM64_OpCom8(v) case OpConst16: - return rewriteValueARM64_OpConst16(v, config) + return rewriteValueARM64_OpConst16(v) case OpConst32: - return rewriteValueARM64_OpConst32(v, config) + return rewriteValueARM64_OpConst32(v) case OpConst32F: - return rewriteValueARM64_OpConst32F(v, config) + return rewriteValueARM64_OpConst32F(v) case OpConst64: - return rewriteValueARM64_OpConst64(v, config) + return rewriteValueARM64_OpConst64(v) case OpConst64F: - return rewriteValueARM64_OpConst64F(v, config) + return rewriteValueARM64_OpConst64F(v) case OpConst8: - return rewriteValueARM64_OpConst8(v, config) + return rewriteValueARM64_OpConst8(v) case OpConstBool: - return rewriteValueARM64_OpConstBool(v, config) + return rewriteValueARM64_OpConstBool(v) case OpConstNil: - return rewriteValueARM64_OpConstNil(v, config) + return rewriteValueARM64_OpConstNil(v) case OpConvert: - return rewriteValueARM64_OpConvert(v, config) + return rewriteValueARM64_OpConvert(v) case OpCtz32: - return rewriteValueARM64_OpCtz32(v, config) + return rewriteValueARM64_OpCtz32(v) case OpCtz64: - return rewriteValueARM64_OpCtz64(v, config) + return rewriteValueARM64_OpCtz64(v) case OpCvt32Fto32: - return rewriteValueARM64_OpCvt32Fto32(v, config) + return rewriteValueARM64_OpCvt32Fto32(v) case OpCvt32Fto32U: - return rewriteValueARM64_OpCvt32Fto32U(v, config) + return rewriteValueARM64_OpCvt32Fto32U(v) case OpCvt32Fto64: - return rewriteValueARM64_OpCvt32Fto64(v, config) + return rewriteValueARM64_OpCvt32Fto64(v) case OpCvt32Fto64F: - return rewriteValueARM64_OpCvt32Fto64F(v, config) + return rewriteValueARM64_OpCvt32Fto64F(v) case OpCvt32Fto64U: - return rewriteValueARM64_OpCvt32Fto64U(v, config) + return rewriteValueARM64_OpCvt32Fto64U(v) case OpCvt32Uto32F: - return rewriteValueARM64_OpCvt32Uto32F(v, config) + return rewriteValueARM64_OpCvt32Uto32F(v) case OpCvt32Uto64F: - return rewriteValueARM64_OpCvt32Uto64F(v, config) + return rewriteValueARM64_OpCvt32Uto64F(v) case OpCvt32to32F: - return rewriteValueARM64_OpCvt32to32F(v, config) + return rewriteValueARM64_OpCvt32to32F(v) case OpCvt32to64F: - return rewriteValueARM64_OpCvt32to64F(v, config) + return rewriteValueARM64_OpCvt32to64F(v) case OpCvt64Fto32: - return rewriteValueARM64_OpCvt64Fto32(v, config) + return rewriteValueARM64_OpCvt64Fto32(v) case OpCvt64Fto32F: - return rewriteValueARM64_OpCvt64Fto32F(v, config) + return rewriteValueARM64_OpCvt64Fto32F(v) case OpCvt64Fto32U: - return rewriteValueARM64_OpCvt64Fto32U(v, config) + return rewriteValueARM64_OpCvt64Fto32U(v) case OpCvt64Fto64: - return rewriteValueARM64_OpCvt64Fto64(v, config) + return rewriteValueARM64_OpCvt64Fto64(v) case OpCvt64Fto64U: - return rewriteValueARM64_OpCvt64Fto64U(v, config) + return rewriteValueARM64_OpCvt64Fto64U(v) case OpCvt64Uto32F: - return rewriteValueARM64_OpCvt64Uto32F(v, config) + return rewriteValueARM64_OpCvt64Uto32F(v) case OpCvt64Uto64F: - return rewriteValueARM64_OpCvt64Uto64F(v, config) + return rewriteValueARM64_OpCvt64Uto64F(v) case OpCvt64to32F: - return rewriteValueARM64_OpCvt64to32F(v, config) + return rewriteValueARM64_OpCvt64to32F(v) case OpCvt64to64F: - return rewriteValueARM64_OpCvt64to64F(v, config) + return rewriteValueARM64_OpCvt64to64F(v) case OpDiv16: - return rewriteValueARM64_OpDiv16(v, config) + return rewriteValueARM64_OpDiv16(v) case OpDiv16u: - return rewriteValueARM64_OpDiv16u(v, config) + return rewriteValueARM64_OpDiv16u(v) case OpDiv32: - return rewriteValueARM64_OpDiv32(v, config) + return rewriteValueARM64_OpDiv32(v) case OpDiv32F: - return rewriteValueARM64_OpDiv32F(v, config) + return rewriteValueARM64_OpDiv32F(v) case OpDiv32u: - return rewriteValueARM64_OpDiv32u(v, config) + return rewriteValueARM64_OpDiv32u(v) case OpDiv64: - return rewriteValueARM64_OpDiv64(v, config) + return rewriteValueARM64_OpDiv64(v) case OpDiv64F: - return rewriteValueARM64_OpDiv64F(v, config) + return rewriteValueARM64_OpDiv64F(v) case OpDiv64u: - return rewriteValueARM64_OpDiv64u(v, config) + return rewriteValueARM64_OpDiv64u(v) case OpDiv8: - return rewriteValueARM64_OpDiv8(v, config) + return rewriteValueARM64_OpDiv8(v) case OpDiv8u: - return rewriteValueARM64_OpDiv8u(v, config) + return rewriteValueARM64_OpDiv8u(v) case OpEq16: - return rewriteValueARM64_OpEq16(v, config) + return rewriteValueARM64_OpEq16(v) case OpEq32: - return rewriteValueARM64_OpEq32(v, config) + return rewriteValueARM64_OpEq32(v) case OpEq32F: - return rewriteValueARM64_OpEq32F(v, config) + return rewriteValueARM64_OpEq32F(v) case OpEq64: - return rewriteValueARM64_OpEq64(v, config) + return rewriteValueARM64_OpEq64(v) case OpEq64F: - return rewriteValueARM64_OpEq64F(v, config) + return rewriteValueARM64_OpEq64F(v) case OpEq8: - return rewriteValueARM64_OpEq8(v, config) + return rewriteValueARM64_OpEq8(v) case OpEqB: - return rewriteValueARM64_OpEqB(v, config) + return rewriteValueARM64_OpEqB(v) case OpEqPtr: - return rewriteValueARM64_OpEqPtr(v, config) + return rewriteValueARM64_OpEqPtr(v) case OpGeq16: - return rewriteValueARM64_OpGeq16(v, config) + return rewriteValueARM64_OpGeq16(v) case OpGeq16U: - return rewriteValueARM64_OpGeq16U(v, config) + return rewriteValueARM64_OpGeq16U(v) case OpGeq32: - return rewriteValueARM64_OpGeq32(v, config) + return rewriteValueARM64_OpGeq32(v) case OpGeq32F: - return rewriteValueARM64_OpGeq32F(v, config) + return rewriteValueARM64_OpGeq32F(v) case OpGeq32U: - return rewriteValueARM64_OpGeq32U(v, config) + return rewriteValueARM64_OpGeq32U(v) case OpGeq64: - return rewriteValueARM64_OpGeq64(v, config) + return rewriteValueARM64_OpGeq64(v) case OpGeq64F: - return rewriteValueARM64_OpGeq64F(v, config) + return rewriteValueARM64_OpGeq64F(v) case OpGeq64U: - return rewriteValueARM64_OpGeq64U(v, config) + return rewriteValueARM64_OpGeq64U(v) case OpGeq8: - return rewriteValueARM64_OpGeq8(v, config) + return rewriteValueARM64_OpGeq8(v) case OpGeq8U: - return rewriteValueARM64_OpGeq8U(v, config) + return rewriteValueARM64_OpGeq8U(v) case OpGetClosurePtr: - return rewriteValueARM64_OpGetClosurePtr(v, config) + return rewriteValueARM64_OpGetClosurePtr(v) case OpGreater16: - return rewriteValueARM64_OpGreater16(v, config) + return rewriteValueARM64_OpGreater16(v) case OpGreater16U: - return rewriteValueARM64_OpGreater16U(v, config) + return rewriteValueARM64_OpGreater16U(v) case OpGreater32: - return rewriteValueARM64_OpGreater32(v, config) + return rewriteValueARM64_OpGreater32(v) case OpGreater32F: - return rewriteValueARM64_OpGreater32F(v, config) + return rewriteValueARM64_OpGreater32F(v) case OpGreater32U: - return rewriteValueARM64_OpGreater32U(v, config) + return rewriteValueARM64_OpGreater32U(v) case OpGreater64: - return rewriteValueARM64_OpGreater64(v, config) + return rewriteValueARM64_OpGreater64(v) case OpGreater64F: - return rewriteValueARM64_OpGreater64F(v, config) + return rewriteValueARM64_OpGreater64F(v) case OpGreater64U: - return rewriteValueARM64_OpGreater64U(v, config) + return rewriteValueARM64_OpGreater64U(v) case OpGreater8: - return rewriteValueARM64_OpGreater8(v, config) + return rewriteValueARM64_OpGreater8(v) case OpGreater8U: - return rewriteValueARM64_OpGreater8U(v, config) + return rewriteValueARM64_OpGreater8U(v) case OpHmul32: - return rewriteValueARM64_OpHmul32(v, config) + return rewriteValueARM64_OpHmul32(v) case OpHmul32u: - return rewriteValueARM64_OpHmul32u(v, config) + return rewriteValueARM64_OpHmul32u(v) case OpHmul64: - return rewriteValueARM64_OpHmul64(v, config) + return rewriteValueARM64_OpHmul64(v) case OpHmul64u: - return rewriteValueARM64_OpHmul64u(v, config) + return rewriteValueARM64_OpHmul64u(v) case OpInterCall: - return rewriteValueARM64_OpInterCall(v, config) + return rewriteValueARM64_OpInterCall(v) case OpIsInBounds: - return rewriteValueARM64_OpIsInBounds(v, config) + return rewriteValueARM64_OpIsInBounds(v) case OpIsNonNil: - return rewriteValueARM64_OpIsNonNil(v, config) + return rewriteValueARM64_OpIsNonNil(v) case OpIsSliceInBounds: - return rewriteValueARM64_OpIsSliceInBounds(v, config) + return rewriteValueARM64_OpIsSliceInBounds(v) case OpLeq16: - return rewriteValueARM64_OpLeq16(v, config) + return rewriteValueARM64_OpLeq16(v) case OpLeq16U: - return rewriteValueARM64_OpLeq16U(v, config) + return rewriteValueARM64_OpLeq16U(v) case OpLeq32: - return rewriteValueARM64_OpLeq32(v, config) + return rewriteValueARM64_OpLeq32(v) case OpLeq32F: - return rewriteValueARM64_OpLeq32F(v, config) + return rewriteValueARM64_OpLeq32F(v) case OpLeq32U: - return rewriteValueARM64_OpLeq32U(v, config) + return rewriteValueARM64_OpLeq32U(v) case OpLeq64: - return rewriteValueARM64_OpLeq64(v, config) + return rewriteValueARM64_OpLeq64(v) case OpLeq64F: - return rewriteValueARM64_OpLeq64F(v, config) + return rewriteValueARM64_OpLeq64F(v) case OpLeq64U: - return rewriteValueARM64_OpLeq64U(v, config) + return rewriteValueARM64_OpLeq64U(v) case OpLeq8: - return rewriteValueARM64_OpLeq8(v, config) + return rewriteValueARM64_OpLeq8(v) case OpLeq8U: - return rewriteValueARM64_OpLeq8U(v, config) + return rewriteValueARM64_OpLeq8U(v) case OpLess16: - return rewriteValueARM64_OpLess16(v, config) + return rewriteValueARM64_OpLess16(v) case OpLess16U: - return rewriteValueARM64_OpLess16U(v, config) + return rewriteValueARM64_OpLess16U(v) case OpLess32: - return rewriteValueARM64_OpLess32(v, config) + return rewriteValueARM64_OpLess32(v) case OpLess32F: - return rewriteValueARM64_OpLess32F(v, config) + return rewriteValueARM64_OpLess32F(v) case OpLess32U: - return rewriteValueARM64_OpLess32U(v, config) + return rewriteValueARM64_OpLess32U(v) case OpLess64: - return rewriteValueARM64_OpLess64(v, config) + return rewriteValueARM64_OpLess64(v) case OpLess64F: - return rewriteValueARM64_OpLess64F(v, config) + return rewriteValueARM64_OpLess64F(v) case OpLess64U: - return rewriteValueARM64_OpLess64U(v, config) + return rewriteValueARM64_OpLess64U(v) case OpLess8: - return rewriteValueARM64_OpLess8(v, config) + return rewriteValueARM64_OpLess8(v) case OpLess8U: - return rewriteValueARM64_OpLess8U(v, config) + return rewriteValueARM64_OpLess8U(v) case OpLoad: - return rewriteValueARM64_OpLoad(v, config) + return rewriteValueARM64_OpLoad(v) case OpLsh16x16: - return rewriteValueARM64_OpLsh16x16(v, config) + return rewriteValueARM64_OpLsh16x16(v) case OpLsh16x32: - return rewriteValueARM64_OpLsh16x32(v, config) + return rewriteValueARM64_OpLsh16x32(v) case OpLsh16x64: - return rewriteValueARM64_OpLsh16x64(v, config) + return rewriteValueARM64_OpLsh16x64(v) case OpLsh16x8: - return rewriteValueARM64_OpLsh16x8(v, config) + return rewriteValueARM64_OpLsh16x8(v) case OpLsh32x16: - return rewriteValueARM64_OpLsh32x16(v, config) + return rewriteValueARM64_OpLsh32x16(v) case OpLsh32x32: - return rewriteValueARM64_OpLsh32x32(v, config) + return rewriteValueARM64_OpLsh32x32(v) case OpLsh32x64: - return rewriteValueARM64_OpLsh32x64(v, config) + return rewriteValueARM64_OpLsh32x64(v) case OpLsh32x8: - return rewriteValueARM64_OpLsh32x8(v, config) + return rewriteValueARM64_OpLsh32x8(v) case OpLsh64x16: - return rewriteValueARM64_OpLsh64x16(v, config) + return rewriteValueARM64_OpLsh64x16(v) case OpLsh64x32: - return rewriteValueARM64_OpLsh64x32(v, config) + return rewriteValueARM64_OpLsh64x32(v) case OpLsh64x64: - return rewriteValueARM64_OpLsh64x64(v, config) + return rewriteValueARM64_OpLsh64x64(v) case OpLsh64x8: - return rewriteValueARM64_OpLsh64x8(v, config) + return rewriteValueARM64_OpLsh64x8(v) case OpLsh8x16: - return rewriteValueARM64_OpLsh8x16(v, config) + return rewriteValueARM64_OpLsh8x16(v) case OpLsh8x32: - return rewriteValueARM64_OpLsh8x32(v, config) + return rewriteValueARM64_OpLsh8x32(v) case OpLsh8x64: - return rewriteValueARM64_OpLsh8x64(v, config) + return rewriteValueARM64_OpLsh8x64(v) case OpLsh8x8: - return rewriteValueARM64_OpLsh8x8(v, config) + return rewriteValueARM64_OpLsh8x8(v) case OpMod16: - return rewriteValueARM64_OpMod16(v, config) + return rewriteValueARM64_OpMod16(v) case OpMod16u: - return rewriteValueARM64_OpMod16u(v, config) + return rewriteValueARM64_OpMod16u(v) case OpMod32: - return rewriteValueARM64_OpMod32(v, config) + return rewriteValueARM64_OpMod32(v) case OpMod32u: - return rewriteValueARM64_OpMod32u(v, config) + return rewriteValueARM64_OpMod32u(v) case OpMod64: - return rewriteValueARM64_OpMod64(v, config) + return rewriteValueARM64_OpMod64(v) case OpMod64u: - return rewriteValueARM64_OpMod64u(v, config) + return rewriteValueARM64_OpMod64u(v) case OpMod8: - return rewriteValueARM64_OpMod8(v, config) + return rewriteValueARM64_OpMod8(v) case OpMod8u: - return rewriteValueARM64_OpMod8u(v, config) + return rewriteValueARM64_OpMod8u(v) case OpMove: - return rewriteValueARM64_OpMove(v, config) + return rewriteValueARM64_OpMove(v) case OpMul16: - return rewriteValueARM64_OpMul16(v, config) + return rewriteValueARM64_OpMul16(v) case OpMul32: - return rewriteValueARM64_OpMul32(v, config) + return rewriteValueARM64_OpMul32(v) case OpMul32F: - return rewriteValueARM64_OpMul32F(v, config) + return rewriteValueARM64_OpMul32F(v) case OpMul64: - return rewriteValueARM64_OpMul64(v, config) + return rewriteValueARM64_OpMul64(v) case OpMul64F: - return rewriteValueARM64_OpMul64F(v, config) + return rewriteValueARM64_OpMul64F(v) case OpMul8: - return rewriteValueARM64_OpMul8(v, config) + return rewriteValueARM64_OpMul8(v) case OpNeg16: - return rewriteValueARM64_OpNeg16(v, config) + return rewriteValueARM64_OpNeg16(v) case OpNeg32: - return rewriteValueARM64_OpNeg32(v, config) + return rewriteValueARM64_OpNeg32(v) case OpNeg32F: - return rewriteValueARM64_OpNeg32F(v, config) + return rewriteValueARM64_OpNeg32F(v) case OpNeg64: - return rewriteValueARM64_OpNeg64(v, config) + return rewriteValueARM64_OpNeg64(v) case OpNeg64F: - return rewriteValueARM64_OpNeg64F(v, config) + return rewriteValueARM64_OpNeg64F(v) case OpNeg8: - return rewriteValueARM64_OpNeg8(v, config) + return rewriteValueARM64_OpNeg8(v) case OpNeq16: - return rewriteValueARM64_OpNeq16(v, config) + return rewriteValueARM64_OpNeq16(v) case OpNeq32: - return rewriteValueARM64_OpNeq32(v, config) + return rewriteValueARM64_OpNeq32(v) case OpNeq32F: - return rewriteValueARM64_OpNeq32F(v, config) + return rewriteValueARM64_OpNeq32F(v) case OpNeq64: - return rewriteValueARM64_OpNeq64(v, config) + return rewriteValueARM64_OpNeq64(v) case OpNeq64F: - return rewriteValueARM64_OpNeq64F(v, config) + return rewriteValueARM64_OpNeq64F(v) case OpNeq8: - return rewriteValueARM64_OpNeq8(v, config) + return rewriteValueARM64_OpNeq8(v) case OpNeqB: - return rewriteValueARM64_OpNeqB(v, config) + return rewriteValueARM64_OpNeqB(v) case OpNeqPtr: - return rewriteValueARM64_OpNeqPtr(v, config) + return rewriteValueARM64_OpNeqPtr(v) case OpNilCheck: - return rewriteValueARM64_OpNilCheck(v, config) + return rewriteValueARM64_OpNilCheck(v) case OpNot: - return rewriteValueARM64_OpNot(v, config) + return rewriteValueARM64_OpNot(v) case OpOffPtr: - return rewriteValueARM64_OpOffPtr(v, config) + return rewriteValueARM64_OpOffPtr(v) case OpOr16: - return rewriteValueARM64_OpOr16(v, config) + return rewriteValueARM64_OpOr16(v) case OpOr32: - return rewriteValueARM64_OpOr32(v, config) + return rewriteValueARM64_OpOr32(v) case OpOr64: - return rewriteValueARM64_OpOr64(v, config) + return rewriteValueARM64_OpOr64(v) case OpOr8: - return rewriteValueARM64_OpOr8(v, config) + return rewriteValueARM64_OpOr8(v) case OpOrB: - return rewriteValueARM64_OpOrB(v, config) + return rewriteValueARM64_OpOrB(v) case OpRound32F: - return rewriteValueARM64_OpRound32F(v, config) + return rewriteValueARM64_OpRound32F(v) case OpRound64F: - return rewriteValueARM64_OpRound64F(v, config) + return rewriteValueARM64_OpRound64F(v) case OpRsh16Ux16: - return rewriteValueARM64_OpRsh16Ux16(v, config) + return rewriteValueARM64_OpRsh16Ux16(v) case OpRsh16Ux32: - return rewriteValueARM64_OpRsh16Ux32(v, config) + return rewriteValueARM64_OpRsh16Ux32(v) case OpRsh16Ux64: - return rewriteValueARM64_OpRsh16Ux64(v, config) + return rewriteValueARM64_OpRsh16Ux64(v) case OpRsh16Ux8: - return rewriteValueARM64_OpRsh16Ux8(v, config) + return rewriteValueARM64_OpRsh16Ux8(v) case OpRsh16x16: - return rewriteValueARM64_OpRsh16x16(v, config) + return rewriteValueARM64_OpRsh16x16(v) case OpRsh16x32: - return rewriteValueARM64_OpRsh16x32(v, config) + return rewriteValueARM64_OpRsh16x32(v) case OpRsh16x64: - return rewriteValueARM64_OpRsh16x64(v, config) + return rewriteValueARM64_OpRsh16x64(v) case OpRsh16x8: - return rewriteValueARM64_OpRsh16x8(v, config) + return rewriteValueARM64_OpRsh16x8(v) case OpRsh32Ux16: - return rewriteValueARM64_OpRsh32Ux16(v, config) + return rewriteValueARM64_OpRsh32Ux16(v) case OpRsh32Ux32: - return rewriteValueARM64_OpRsh32Ux32(v, config) + return rewriteValueARM64_OpRsh32Ux32(v) case OpRsh32Ux64: - return rewriteValueARM64_OpRsh32Ux64(v, config) + return rewriteValueARM64_OpRsh32Ux64(v) case OpRsh32Ux8: - return rewriteValueARM64_OpRsh32Ux8(v, config) + return rewriteValueARM64_OpRsh32Ux8(v) case OpRsh32x16: - return rewriteValueARM64_OpRsh32x16(v, config) + return rewriteValueARM64_OpRsh32x16(v) case OpRsh32x32: - return rewriteValueARM64_OpRsh32x32(v, config) + return rewriteValueARM64_OpRsh32x32(v) case OpRsh32x64: - return rewriteValueARM64_OpRsh32x64(v, config) + return rewriteValueARM64_OpRsh32x64(v) case OpRsh32x8: - return rewriteValueARM64_OpRsh32x8(v, config) + return rewriteValueARM64_OpRsh32x8(v) case OpRsh64Ux16: - return rewriteValueARM64_OpRsh64Ux16(v, config) + return rewriteValueARM64_OpRsh64Ux16(v) case OpRsh64Ux32: - return rewriteValueARM64_OpRsh64Ux32(v, config) + return rewriteValueARM64_OpRsh64Ux32(v) case OpRsh64Ux64: - return rewriteValueARM64_OpRsh64Ux64(v, config) + return rewriteValueARM64_OpRsh64Ux64(v) case OpRsh64Ux8: - return rewriteValueARM64_OpRsh64Ux8(v, config) + return rewriteValueARM64_OpRsh64Ux8(v) case OpRsh64x16: - return rewriteValueARM64_OpRsh64x16(v, config) + return rewriteValueARM64_OpRsh64x16(v) case OpRsh64x32: - return rewriteValueARM64_OpRsh64x32(v, config) + return rewriteValueARM64_OpRsh64x32(v) case OpRsh64x64: - return rewriteValueARM64_OpRsh64x64(v, config) + return rewriteValueARM64_OpRsh64x64(v) case OpRsh64x8: - return rewriteValueARM64_OpRsh64x8(v, config) + return rewriteValueARM64_OpRsh64x8(v) case OpRsh8Ux16: - return rewriteValueARM64_OpRsh8Ux16(v, config) + return rewriteValueARM64_OpRsh8Ux16(v) case OpRsh8Ux32: - return rewriteValueARM64_OpRsh8Ux32(v, config) + return rewriteValueARM64_OpRsh8Ux32(v) case OpRsh8Ux64: - return rewriteValueARM64_OpRsh8Ux64(v, config) + return rewriteValueARM64_OpRsh8Ux64(v) case OpRsh8Ux8: - return rewriteValueARM64_OpRsh8Ux8(v, config) + return rewriteValueARM64_OpRsh8Ux8(v) case OpRsh8x16: - return rewriteValueARM64_OpRsh8x16(v, config) + return rewriteValueARM64_OpRsh8x16(v) case OpRsh8x32: - return rewriteValueARM64_OpRsh8x32(v, config) + return rewriteValueARM64_OpRsh8x32(v) case OpRsh8x64: - return rewriteValueARM64_OpRsh8x64(v, config) + return rewriteValueARM64_OpRsh8x64(v) case OpRsh8x8: - return rewriteValueARM64_OpRsh8x8(v, config) + return rewriteValueARM64_OpRsh8x8(v) case OpSignExt16to32: - return rewriteValueARM64_OpSignExt16to32(v, config) + return rewriteValueARM64_OpSignExt16to32(v) case OpSignExt16to64: - return rewriteValueARM64_OpSignExt16to64(v, config) + return rewriteValueARM64_OpSignExt16to64(v) case OpSignExt32to64: - return rewriteValueARM64_OpSignExt32to64(v, config) + return rewriteValueARM64_OpSignExt32to64(v) case OpSignExt8to16: - return rewriteValueARM64_OpSignExt8to16(v, config) + return rewriteValueARM64_OpSignExt8to16(v) case OpSignExt8to32: - return rewriteValueARM64_OpSignExt8to32(v, config) + return rewriteValueARM64_OpSignExt8to32(v) case OpSignExt8to64: - return rewriteValueARM64_OpSignExt8to64(v, config) + return rewriteValueARM64_OpSignExt8to64(v) case OpSlicemask: - return rewriteValueARM64_OpSlicemask(v, config) + return rewriteValueARM64_OpSlicemask(v) case OpSqrt: - return rewriteValueARM64_OpSqrt(v, config) + return rewriteValueARM64_OpSqrt(v) case OpStaticCall: - return rewriteValueARM64_OpStaticCall(v, config) + return rewriteValueARM64_OpStaticCall(v) case OpStore: - return rewriteValueARM64_OpStore(v, config) + return rewriteValueARM64_OpStore(v) case OpSub16: - return rewriteValueARM64_OpSub16(v, config) + return rewriteValueARM64_OpSub16(v) case OpSub32: - return rewriteValueARM64_OpSub32(v, config) + return rewriteValueARM64_OpSub32(v) case OpSub32F: - return rewriteValueARM64_OpSub32F(v, config) + return rewriteValueARM64_OpSub32F(v) case OpSub64: - return rewriteValueARM64_OpSub64(v, config) + return rewriteValueARM64_OpSub64(v) case OpSub64F: - return rewriteValueARM64_OpSub64F(v, config) + return rewriteValueARM64_OpSub64F(v) case OpSub8: - return rewriteValueARM64_OpSub8(v, config) + return rewriteValueARM64_OpSub8(v) case OpSubPtr: - return rewriteValueARM64_OpSubPtr(v, config) + return rewriteValueARM64_OpSubPtr(v) case OpTrunc16to8: - return rewriteValueARM64_OpTrunc16to8(v, config) + return rewriteValueARM64_OpTrunc16to8(v) case OpTrunc32to16: - return rewriteValueARM64_OpTrunc32to16(v, config) + return rewriteValueARM64_OpTrunc32to16(v) case OpTrunc32to8: - return rewriteValueARM64_OpTrunc32to8(v, config) + return rewriteValueARM64_OpTrunc32to8(v) case OpTrunc64to16: - return rewriteValueARM64_OpTrunc64to16(v, config) + return rewriteValueARM64_OpTrunc64to16(v) case OpTrunc64to32: - return rewriteValueARM64_OpTrunc64to32(v, config) + return rewriteValueARM64_OpTrunc64to32(v) case OpTrunc64to8: - return rewriteValueARM64_OpTrunc64to8(v, config) + return rewriteValueARM64_OpTrunc64to8(v) case OpXor16: - return rewriteValueARM64_OpXor16(v, config) + return rewriteValueARM64_OpXor16(v) case OpXor32: - return rewriteValueARM64_OpXor32(v, config) + return rewriteValueARM64_OpXor32(v) case OpXor64: - return rewriteValueARM64_OpXor64(v, config) + return rewriteValueARM64_OpXor64(v) case OpXor8: - return rewriteValueARM64_OpXor8(v, config) + return rewriteValueARM64_OpXor8(v) case OpZero: - return rewriteValueARM64_OpZero(v, config) + return rewriteValueARM64_OpZero(v) case OpZeroExt16to32: - return rewriteValueARM64_OpZeroExt16to32(v, config) + return rewriteValueARM64_OpZeroExt16to32(v) case OpZeroExt16to64: - return rewriteValueARM64_OpZeroExt16to64(v, config) + return rewriteValueARM64_OpZeroExt16to64(v) case OpZeroExt32to64: - return rewriteValueARM64_OpZeroExt32to64(v, config) + return rewriteValueARM64_OpZeroExt32to64(v) case OpZeroExt8to16: - return rewriteValueARM64_OpZeroExt8to16(v, config) + return rewriteValueARM64_OpZeroExt8to16(v) case OpZeroExt8to32: - return rewriteValueARM64_OpZeroExt8to32(v, config) + return rewriteValueARM64_OpZeroExt8to32(v) case OpZeroExt8to64: - return rewriteValueARM64_OpZeroExt8to64(v, config) + return rewriteValueARM64_OpZeroExt8to64(v) } return false } -func rewriteValueARM64_OpARM64ADD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64ADD(v *Value) bool { // match: (ADD (MOVDconst [c]) x) // cond: // result: (ADDconst [c] x) @@ -880,9 +878,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ADDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64ADDconst(v *Value) bool { // match: (ADDconst [off1] (MOVDaddr [off2] {sym} ptr)) // cond: // result: (MOVDaddr [off1+off2] {sym} ptr) @@ -962,7 +958,7 @@ func rewriteValueARM64_OpARM64ADDconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ADDshiftLL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool { b := v.Block _ = b // match: (ADDshiftLL (MOVDconst [c]) x [d]) @@ -1052,7 +1048,7 @@ func rewriteValueARM64_OpARM64ADDshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ADDshiftRA(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRA (MOVDconst [c]) x [d]) @@ -1092,7 +1088,7 @@ func rewriteValueARM64_OpARM64ADDshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ADDshiftRL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRL (MOVDconst [c]) x [d]) @@ -1182,9 +1178,7 @@ func rewriteValueARM64_OpARM64ADDshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64AND(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64AND(v *Value) bool { // match: (AND (MOVDconst [c]) x) // cond: // result: (ANDconst [c] x) @@ -1347,9 +1341,7 @@ func rewriteValueARM64_OpARM64AND(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ANDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64ANDconst(v *Value) bool { // match: (ANDconst [0] _) // cond: // result: (MOVDconst [0]) @@ -1406,7 +1398,7 @@ func rewriteValueARM64_OpARM64ANDconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ANDshiftLL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool { b := v.Block _ = b // match: (ANDshiftLL (MOVDconst [c]) x [d]) @@ -1468,7 +1460,7 @@ func rewriteValueARM64_OpARM64ANDshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ANDshiftRA(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRA (MOVDconst [c]) x [d]) @@ -1530,7 +1522,7 @@ func rewriteValueARM64_OpARM64ANDshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ANDshiftRL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRL (MOVDconst [c]) x [d]) @@ -1592,9 +1584,7 @@ func rewriteValueARM64_OpARM64ANDshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64BIC(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64BIC(v *Value) bool { // match: (BIC x (MOVDconst [c])) // cond: // result: (BICconst [c] x) @@ -1675,9 +1665,7 @@ func rewriteValueARM64_OpARM64BIC(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64BICconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64BICconst(v *Value) bool { // match: (BICconst [0] x) // cond: // result: x @@ -1718,9 +1706,7 @@ func rewriteValueARM64_OpARM64BICconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64BICshiftLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64BICshiftLL(v *Value) bool { // match: (BICshiftLL x (MOVDconst [c]) [d]) // cond: // result: (BICconst x [int64(uint64(c)<<uint64(d))]) @@ -1760,9 +1746,7 @@ func rewriteValueARM64_OpARM64BICshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64BICshiftRA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64BICshiftRA(v *Value) bool { // match: (BICshiftRA x (MOVDconst [c]) [d]) // cond: // result: (BICconst x [int64(int64(c)>>uint64(d))]) @@ -1802,9 +1786,7 @@ func rewriteValueARM64_OpARM64BICshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64BICshiftRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool { // match: (BICshiftRL x (MOVDconst [c]) [d]) // cond: // result: (BICconst x [int64(uint64(c)>>uint64(d))]) @@ -1844,7 +1826,7 @@ func rewriteValueARM64_OpARM64BICshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64CMP(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64CMP(v *Value) bool { b := v.Block _ = b // match: (CMP x (MOVDconst [c])) @@ -1989,7 +1971,7 @@ func rewriteValueARM64_OpARM64CMP(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64CMPW(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64CMPW(v *Value) bool { b := v.Block _ = b // match: (CMPW x (MOVDconst [c])) @@ -2026,9 +2008,7 @@ func rewriteValueARM64_OpARM64CMPW(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64CMPWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool { // match: (CMPWconst (MOVDconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -2141,9 +2121,7 @@ func rewriteValueARM64_OpARM64CMPWconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64CMPconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64CMPconst(v *Value) bool { // match: (CMPconst (MOVDconst [x]) [y]) // cond: x==y // result: (FlagEQ) @@ -2303,7 +2281,7 @@ func rewriteValueARM64_OpARM64CMPconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64CMPshiftLL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool { b := v.Block _ = b // match: (CMPshiftLL (MOVDconst [c]) x [d]) @@ -2345,7 +2323,7 @@ func rewriteValueARM64_OpARM64CMPshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64CMPshiftRA(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRA (MOVDconst [c]) x [d]) @@ -2387,7 +2365,7 @@ func rewriteValueARM64_OpARM64CMPshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64CMPshiftRL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRL (MOVDconst [c]) x [d]) @@ -2429,9 +2407,7 @@ func rewriteValueARM64_OpARM64CMPshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64CSELULT(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64CSELULT(v *Value) bool { // match: (CSELULT x (MOVDconst [0]) flag) // cond: // result: (CSELULT0 x flag) @@ -2522,9 +2498,7 @@ func rewriteValueARM64_OpARM64CSELULT(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64CSELULT0(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64CSELULT0(v *Value) bool { // match: (CSELULT0 _ (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -2591,9 +2565,7 @@ func rewriteValueARM64_OpARM64CSELULT0(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64DIV(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64DIV(v *Value) bool { // match: (DIV (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [int64(c)/int64(d)]) @@ -2614,9 +2586,7 @@ func rewriteValueARM64_OpARM64DIV(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64DIVW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64DIVW(v *Value) bool { // match: (DIVW (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [int64(int32(c)/int32(d))]) @@ -2637,9 +2607,7 @@ func rewriteValueARM64_OpARM64DIVW(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64Equal(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64Equal(v *Value) bool { // match: (Equal (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -2715,9 +2683,7 @@ func rewriteValueARM64_OpARM64Equal(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64FMOVDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool { // match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%8==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (FMOVDload [off1+off2] {sym} ptr mem) @@ -2767,9 +2733,7 @@ func rewriteValueARM64_OpARM64FMOVDload(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64FMOVDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool { // match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%8==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (FMOVDstore [off1+off2] {sym} ptr val mem) @@ -2823,9 +2787,7 @@ func rewriteValueARM64_OpARM64FMOVDstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64FMOVSload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool { // match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%4==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (FMOVSload [off1+off2] {sym} ptr mem) @@ -2875,9 +2837,7 @@ func rewriteValueARM64_OpARM64FMOVSload(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64FMOVSstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool { // match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%4==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (FMOVSstore [off1+off2] {sym} ptr val mem) @@ -2931,9 +2891,7 @@ func rewriteValueARM64_OpARM64FMOVSstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64GreaterEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool { // match: (GreaterEqual (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -3009,9 +2967,7 @@ func rewriteValueARM64_OpARM64GreaterEqual(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64GreaterEqualU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64GreaterEqualU(v *Value) bool { // match: (GreaterEqualU (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -3087,9 +3043,7 @@ func rewriteValueARM64_OpARM64GreaterEqualU(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64GreaterThan(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool { // match: (GreaterThan (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -3165,9 +3119,7 @@ func rewriteValueARM64_OpARM64GreaterThan(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64GreaterThanU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool { // match: (GreaterThanU (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -3243,9 +3195,7 @@ func rewriteValueARM64_OpARM64GreaterThanU(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64LessEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64LessEqual(v *Value) bool { // match: (LessEqual (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -3321,9 +3271,7 @@ func rewriteValueARM64_OpARM64LessEqual(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64LessEqualU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool { // match: (LessEqualU (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -3399,9 +3347,7 @@ func rewriteValueARM64_OpARM64LessEqualU(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64LessThan(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64LessThan(v *Value) bool { // match: (LessThan (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -3477,9 +3423,7 @@ func rewriteValueARM64_OpARM64LessThan(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64LessThanU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64LessThanU(v *Value) bool { // match: (LessThanU (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -3555,9 +3499,7 @@ func rewriteValueARM64_OpARM64LessThanU(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOD(v *Value) bool { // match: (MOD (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [int64(c)%int64(d)]) @@ -3578,9 +3520,7 @@ func rewriteValueARM64_OpARM64MOD(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MODW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MODW(v *Value) bool { // match: (MODW (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [int64(int32(c)%int32(d))]) @@ -3601,9 +3541,7 @@ func rewriteValueARM64_OpARM64MODW(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVBUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool { // match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVBUload [off1+off2] {sym} ptr mem) @@ -3674,9 +3612,7 @@ func rewriteValueARM64_OpARM64MOVBUload(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVBUreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool { // match: (MOVBUreg x:(MOVBUload _ _)) // cond: // result: (MOVDreg x) @@ -3716,9 +3652,7 @@ func rewriteValueARM64_OpARM64MOVBUreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVBload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVBload(v *Value) bool { // match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -3789,9 +3723,7 @@ func rewriteValueARM64_OpARM64MOVBload(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVBreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool { // match: (MOVBreg x:(MOVBload _ _)) // cond: // result: (MOVDreg x) @@ -3831,9 +3763,7 @@ func rewriteValueARM64_OpARM64MOVBreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVBstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool { // match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVBstore [off1+off2] {sym} ptr val mem) @@ -4035,9 +3965,7 @@ func rewriteValueARM64_OpARM64MOVBstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVBstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVBstorezero(v *Value) bool { // match: (MOVBstorezero [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVBstorezero [off1+off2] {sym} ptr mem) @@ -4087,9 +4015,7 @@ func rewriteValueARM64_OpARM64MOVBstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVDload(v *Value) bool { // match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%8==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVDload [off1+off2] {sym} ptr mem) @@ -4160,9 +4086,7 @@ func rewriteValueARM64_OpARM64MOVDload(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVDreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool { // match: (MOVDreg x) // cond: x.Uses == 1 // result: (MOVDnop x) @@ -4190,9 +4114,7 @@ func rewriteValueARM64_OpARM64MOVDreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%8==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -4268,9 +4190,7 @@ func rewriteValueARM64_OpARM64MOVDstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVDstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool { // match: (MOVDstorezero [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%2==8 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVDstorezero [off1+off2] {sym} ptr mem) @@ -4320,9 +4240,7 @@ func rewriteValueARM64_OpARM64MOVDstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVHUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool { // match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%2==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVHUload [off1+off2] {sym} ptr mem) @@ -4393,9 +4311,7 @@ func rewriteValueARM64_OpARM64MOVHUload(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVHUreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool { // match: (MOVHUreg x:(MOVBUload _ _)) // cond: // result: (MOVDreg x) @@ -4459,9 +4375,7 @@ func rewriteValueARM64_OpARM64MOVHUreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVHload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVHload(v *Value) bool { // match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%2==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -4532,9 +4446,7 @@ func rewriteValueARM64_OpARM64MOVHload(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVHreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool { // match: (MOVHreg x:(MOVBload _ _)) // cond: // result: (MOVDreg x) @@ -4622,9 +4534,7 @@ func rewriteValueARM64_OpARM64MOVHreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVHstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool { // match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%2==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVHstore [off1+off2] {sym} ptr val mem) @@ -4784,9 +4694,7 @@ func rewriteValueARM64_OpARM64MOVHstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVHstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool { // match: (MOVHstorezero [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%2==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVHstorezero [off1+off2] {sym} ptr mem) @@ -4836,9 +4744,7 @@ func rewriteValueARM64_OpARM64MOVHstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVWUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool { // match: (MOVWUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%4==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVWUload [off1+off2] {sym} ptr mem) @@ -4909,9 +4815,7 @@ func rewriteValueARM64_OpARM64MOVWUload(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVWUreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool { // match: (MOVWUreg x:(MOVBUload _ _)) // cond: // result: (MOVDreg x) @@ -4999,9 +4903,7 @@ func rewriteValueARM64_OpARM64MOVWUreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVWload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVWload(v *Value) bool { // match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%4==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVWload [off1+off2] {sym} ptr mem) @@ -5072,9 +4974,7 @@ func rewriteValueARM64_OpARM64MOVWload(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVWreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool { // match: (MOVWreg x:(MOVBload _ _)) // cond: // result: (MOVDreg x) @@ -5210,9 +5110,7 @@ func rewriteValueARM64_OpARM64MOVWreg(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVWstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool { // match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%4==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVWstore [off1+off2] {sym} ptr val mem) @@ -5330,9 +5228,7 @@ func rewriteValueARM64_OpARM64MOVWstore(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MOVWstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool { // match: (MOVWstorezero [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is32Bit(off1+off2) && !isArg(sym) && ((off1+off2)%4==0 || off1+off2<256 && off1+off2>-256 && !isAuto(sym)) // result: (MOVWstorezero [off1+off2] {sym} ptr mem) @@ -5382,7 +5278,7 @@ func rewriteValueARM64_OpARM64MOVWstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MUL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64MUL(v *Value) bool { b := v.Block _ = b // match: (MUL x (MOVDconst [-1])) @@ -5815,7 +5711,7 @@ func rewriteValueARM64_OpARM64MUL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MULW(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64MULW(v *Value) bool { b := v.Block _ = b // match: (MULW x (MOVDconst [c])) @@ -6236,9 +6132,7 @@ func rewriteValueARM64_OpARM64MULW(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64MVN(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MVN(v *Value) bool { // match: (MVN (MOVDconst [c])) // cond: // result: (MOVDconst [^c]) @@ -6254,9 +6148,7 @@ func rewriteValueARM64_OpARM64MVN(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64NEG(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64NEG(v *Value) bool { // match: (NEG (MOVDconst [c])) // cond: // result: (MOVDconst [-c]) @@ -6272,9 +6164,7 @@ func rewriteValueARM64_OpARM64NEG(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64NotEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64NotEqual(v *Value) bool { // match: (NotEqual (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -6350,7 +6240,7 @@ func rewriteValueARM64_OpARM64NotEqual(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64OR(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64OR(v *Value) bool { b := v.Block _ = b // match: (OR (MOVDconst [c]) x) @@ -7214,9 +7104,7 @@ func rewriteValueARM64_OpARM64OR(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64ORconst(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -7273,7 +7161,7 @@ func rewriteValueARM64_OpARM64ORconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ORshiftLL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool { b := v.Block _ = b // match: (ORshiftLL (MOVDconst [c]) x [d]) @@ -7927,7 +7815,7 @@ func rewriteValueARM64_OpARM64ORshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ORshiftRA(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool { b := v.Block _ = b // match: (ORshiftRA (MOVDconst [c]) x [d]) @@ -7989,7 +7877,7 @@ func rewriteValueARM64_OpARM64ORshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64ORshiftRL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool { b := v.Block _ = b // match: (ORshiftRL (MOVDconst [c]) x [d]) @@ -8101,9 +7989,7 @@ func rewriteValueARM64_OpARM64ORshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SLL(v *Value) bool { // match: (SLL x (MOVDconst [c])) // cond: // result: (SLLconst x [c&63]) @@ -8121,9 +8007,7 @@ func rewriteValueARM64_OpARM64SLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SLLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SLLconst(v *Value) bool { // match: (SLLconst [c] (MOVDconst [d])) // cond: // result: (MOVDconst [int64(d)<<uint64(c)]) @@ -8140,9 +8024,7 @@ func rewriteValueARM64_OpARM64SLLconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SRA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SRA(v *Value) bool { // match: (SRA x (MOVDconst [c])) // cond: // result: (SRAconst x [c&63]) @@ -8160,9 +8042,7 @@ func rewriteValueARM64_OpARM64SRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SRAconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SRAconst(v *Value) bool { // match: (SRAconst [c] (MOVDconst [d])) // cond: // result: (MOVDconst [int64(d)>>uint64(c)]) @@ -8179,9 +8059,7 @@ func rewriteValueARM64_OpARM64SRAconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SRL(v *Value) bool { // match: (SRL x (MOVDconst [c])) // cond: // result: (SRLconst x [c&63]) @@ -8199,9 +8077,7 @@ func rewriteValueARM64_OpARM64SRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SRLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SRLconst(v *Value) bool { // match: (SRLconst [c] (MOVDconst [d])) // cond: // result: (MOVDconst [int64(uint64(d)>>uint64(c))]) @@ -8218,7 +8094,7 @@ func rewriteValueARM64_OpARM64SRLconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SUB(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64SUB(v *Value) bool { b := v.Block _ = b // match: (SUB x (MOVDconst [c])) @@ -8339,9 +8215,7 @@ func rewriteValueARM64_OpARM64SUB(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SUBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SUBconst(v *Value) bool { // match: (SUBconst [0] x) // cond: // result: x @@ -8403,9 +8277,7 @@ func rewriteValueARM64_OpARM64SUBconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SUBshiftLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SUBshiftLL(v *Value) bool { // match: (SUBshiftLL x (MOVDconst [c]) [d]) // cond: // result: (SUBconst x [int64(uint64(c)<<uint64(d))]) @@ -8445,9 +8317,7 @@ func rewriteValueARM64_OpARM64SUBshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SUBshiftRA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SUBshiftRA(v *Value) bool { // match: (SUBshiftRA x (MOVDconst [c]) [d]) // cond: // result: (SUBconst x [int64(int64(c)>>uint64(d))]) @@ -8487,9 +8357,7 @@ func rewriteValueARM64_OpARM64SUBshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64SUBshiftRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool { // match: (SUBshiftRL x (MOVDconst [c]) [d]) // cond: // result: (SUBconst x [int64(uint64(c)>>uint64(d))]) @@ -8529,9 +8397,7 @@ func rewriteValueARM64_OpARM64SUBshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64UDIV(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64UDIV(v *Value) bool { // match: (UDIV x (MOVDconst [1])) // cond: // result: x @@ -8587,9 +8453,7 @@ func rewriteValueARM64_OpARM64UDIV(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64UDIVW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64UDIVW(v *Value) bool { // match: (UDIVW x (MOVDconst [c])) // cond: uint32(c)==1 // result: x @@ -8646,9 +8510,7 @@ func rewriteValueARM64_OpARM64UDIVW(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64UMOD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64UMOD(v *Value) bool { // match: (UMOD _ (MOVDconst [1])) // cond: // result: (MOVDconst [0]) @@ -8702,9 +8564,7 @@ func rewriteValueARM64_OpARM64UMOD(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64UMODW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64UMODW(v *Value) bool { // match: (UMODW _ (MOVDconst [c])) // cond: uint32(c)==1 // result: (MOVDconst [0]) @@ -8759,9 +8619,7 @@ func rewriteValueARM64_OpARM64UMODW(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64XOR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64XOR(v *Value) bool { // match: (XOR (MOVDconst [c]) x) // cond: // result: (XORconst [c] x) @@ -8908,9 +8766,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64XORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64XORconst(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -8968,7 +8824,7 @@ func rewriteValueARM64_OpARM64XORconst(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64XORshiftLL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool { b := v.Block _ = b // match: (XORshiftLL (MOVDconst [c]) x [d]) @@ -9079,7 +8935,7 @@ func rewriteValueARM64_OpARM64XORshiftLL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64XORshiftRA(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool { b := v.Block _ = b // match: (XORshiftRA (MOVDconst [c]) x [d]) @@ -9140,7 +8996,7 @@ func rewriteValueARM64_OpARM64XORshiftRA(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpARM64XORshiftRL(v *Value, config *Config) bool { +func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool { b := v.Block _ = b // match: (XORshiftRL (MOVDconst [c]) x [d]) @@ -9251,9 +9107,7 @@ func rewriteValueARM64_OpARM64XORshiftRL(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpAdd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAdd16(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADD x y) @@ -9266,9 +9120,7 @@ func rewriteValueARM64_OpAdd16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAdd32(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADD x y) @@ -9281,9 +9133,7 @@ func rewriteValueARM64_OpAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAdd32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAdd32F(v *Value) bool { // match: (Add32F x y) // cond: // result: (FADDS x y) @@ -9296,9 +9146,7 @@ func rewriteValueARM64_OpAdd32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAdd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAdd64(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADD x y) @@ -9311,9 +9159,7 @@ func rewriteValueARM64_OpAdd64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAdd64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAdd64F(v *Value) bool { // match: (Add64F x y) // cond: // result: (FADDD x y) @@ -9326,9 +9172,7 @@ func rewriteValueARM64_OpAdd64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAdd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAdd8(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADD x y) @@ -9341,9 +9185,7 @@ func rewriteValueARM64_OpAdd8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAddPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAddPtr(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -9356,9 +9198,7 @@ func rewriteValueARM64_OpAddPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAddr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAddr(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVDaddr {sym} base) @@ -9371,9 +9211,7 @@ func rewriteValueARM64_OpAddr(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAnd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAnd16(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -9386,9 +9224,7 @@ func rewriteValueARM64_OpAnd16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAnd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAnd32(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -9401,9 +9237,7 @@ func rewriteValueARM64_OpAnd32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAnd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAnd64(v *Value) bool { // match: (And64 x y) // cond: // result: (AND x y) @@ -9416,9 +9250,7 @@ func rewriteValueARM64_OpAnd64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAnd8(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -9431,9 +9263,7 @@ func rewriteValueARM64_OpAnd8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAndB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAndB(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -9446,9 +9276,7 @@ func rewriteValueARM64_OpAndB(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicAdd32(v *Value) bool { // match: (AtomicAdd32 ptr val mem) // cond: // result: (LoweredAtomicAdd32 ptr val mem) @@ -9463,9 +9291,7 @@ func rewriteValueARM64_OpAtomicAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicAdd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicAdd64(v *Value) bool { // match: (AtomicAdd64 ptr val mem) // cond: // result: (LoweredAtomicAdd64 ptr val mem) @@ -9480,9 +9306,7 @@ func rewriteValueARM64_OpAtomicAdd64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicAnd8(v *Value) bool { // match: (AtomicAnd8 ptr val mem) // cond: // result: (LoweredAtomicAnd8 ptr val mem) @@ -9497,9 +9321,7 @@ func rewriteValueARM64_OpAtomicAnd8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicCompareAndSwap32(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (LoweredAtomicCas32 ptr old new_ mem) @@ -9516,9 +9338,7 @@ func rewriteValueARM64_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicCompareAndSwap64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicCompareAndSwap64(v *Value) bool { // match: (AtomicCompareAndSwap64 ptr old new_ mem) // cond: // result: (LoweredAtomicCas64 ptr old new_ mem) @@ -9535,9 +9355,7 @@ func rewriteValueARM64_OpAtomicCompareAndSwap64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicExchange32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicExchange32(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (LoweredAtomicExchange32 ptr val mem) @@ -9552,9 +9370,7 @@ func rewriteValueARM64_OpAtomicExchange32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicExchange64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicExchange64(v *Value) bool { // match: (AtomicExchange64 ptr val mem) // cond: // result: (LoweredAtomicExchange64 ptr val mem) @@ -9569,9 +9385,7 @@ func rewriteValueARM64_OpAtomicExchange64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicLoad32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicLoad32(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (LDARW ptr mem) @@ -9584,9 +9398,7 @@ func rewriteValueARM64_OpAtomicLoad32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicLoad64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicLoad64(v *Value) bool { // match: (AtomicLoad64 ptr mem) // cond: // result: (LDAR ptr mem) @@ -9599,9 +9411,7 @@ func rewriteValueARM64_OpAtomicLoad64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicLoadPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicLoadPtr(v *Value) bool { // match: (AtomicLoadPtr ptr mem) // cond: // result: (LDAR ptr mem) @@ -9614,9 +9424,7 @@ func rewriteValueARM64_OpAtomicLoadPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicOr8(v *Value) bool { // match: (AtomicOr8 ptr val mem) // cond: // result: (LoweredAtomicOr8 ptr val mem) @@ -9631,9 +9439,7 @@ func rewriteValueARM64_OpAtomicOr8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicStore32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicStore32(v *Value) bool { // match: (AtomicStore32 ptr val mem) // cond: // result: (STLRW ptr val mem) @@ -9648,9 +9454,7 @@ func rewriteValueARM64_OpAtomicStore32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicStore64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicStore64(v *Value) bool { // match: (AtomicStore64 ptr val mem) // cond: // result: (STLR ptr val mem) @@ -9665,9 +9469,7 @@ func rewriteValueARM64_OpAtomicStore64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpAtomicStorePtrNoWB(v *Value) bool { // match: (AtomicStorePtrNoWB ptr val mem) // cond: // result: (STLR ptr val mem) @@ -9682,7 +9484,7 @@ func rewriteValueARM64_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpAvg64u(v *Value, config *Config) bool { +func rewriteValueARM64_OpAvg64u(v *Value) bool { b := v.Block _ = b // match: (Avg64u <t> x y) @@ -9704,43 +9506,49 @@ func rewriteValueARM64_OpAvg64u(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpBitLen64(v *Value, config *Config) bool { +func rewriteValueARM64_OpBitLen64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (BitLen64 x) // cond: - // result: (SUB (MOVDconst [64]) (CLZ <config.fe.TypeInt()> x)) + // result: (SUB (MOVDconst [64]) (CLZ <fe.TypeInt()> x)) for { x := v.Args[0] v.reset(OpARM64SUB) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 64 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpARM64CLZ, config.fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpARM64CLZ, fe.TypeInt()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueARM64_OpBitRev16(v *Value, config *Config) bool { +func rewriteValueARM64_OpBitRev16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (BitRev16 x) // cond: - // result: (SRLconst [48] (RBIT <config.fe.TypeUInt64()> x)) + // result: (SRLconst [48] (RBIT <fe.TypeUInt64()> x)) for { x := v.Args[0] v.reset(OpARM64SRLconst) v.AuxInt = 48 - v0 := b.NewValue0(v.Pos, OpARM64RBIT, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64RBIT, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValueARM64_OpBitRev32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpBitRev32(v *Value) bool { // match: (BitRev32 x) // cond: // result: (RBITW x) @@ -9751,9 +9559,7 @@ func rewriteValueARM64_OpBitRev32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpBitRev64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpBitRev64(v *Value) bool { // match: (BitRev64 x) // cond: // result: (RBIT x) @@ -9764,25 +9570,27 @@ func rewriteValueARM64_OpBitRev64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpBitRev8(v *Value, config *Config) bool { +func rewriteValueARM64_OpBitRev8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (BitRev8 x) // cond: - // result: (SRLconst [56] (RBIT <config.fe.TypeUInt64()> x)) + // result: (SRLconst [56] (RBIT <fe.TypeUInt64()> x)) for { x := v.Args[0] v.reset(OpARM64SRLconst) v.AuxInt = 56 - v0 := b.NewValue0(v.Pos, OpARM64RBIT, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64RBIT, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValueARM64_OpBswap32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpBswap32(v *Value) bool { // match: (Bswap32 x) // cond: // result: (REVW x) @@ -9793,9 +9601,7 @@ func rewriteValueARM64_OpBswap32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpBswap64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpBswap64(v *Value) bool { // match: (Bswap64 x) // cond: // result: (REV x) @@ -9806,9 +9612,7 @@ func rewriteValueARM64_OpBswap64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpClosureCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpClosureCall(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -9825,9 +9629,7 @@ func rewriteValueARM64_OpClosureCall(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCom16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCom16(v *Value) bool { // match: (Com16 x) // cond: // result: (MVN x) @@ -9838,9 +9640,7 @@ func rewriteValueARM64_OpCom16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCom32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCom32(v *Value) bool { // match: (Com32 x) // cond: // result: (MVN x) @@ -9851,9 +9651,7 @@ func rewriteValueARM64_OpCom32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCom64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCom64(v *Value) bool { // match: (Com64 x) // cond: // result: (MVN x) @@ -9864,9 +9662,7 @@ func rewriteValueARM64_OpCom64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCom8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCom8(v *Value) bool { // match: (Com8 x) // cond: // result: (MVN x) @@ -9877,9 +9673,7 @@ func rewriteValueARM64_OpCom8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpConst16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpConst16(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVDconst [val]) @@ -9890,9 +9684,7 @@ func rewriteValueARM64_OpConst16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpConst32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpConst32(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVDconst [val]) @@ -9903,9 +9695,7 @@ func rewriteValueARM64_OpConst32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpConst32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpConst32F(v *Value) bool { // match: (Const32F [val]) // cond: // result: (FMOVSconst [val]) @@ -9916,9 +9706,7 @@ func rewriteValueARM64_OpConst32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpConst64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpConst64(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVDconst [val]) @@ -9929,9 +9717,7 @@ func rewriteValueARM64_OpConst64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpConst64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpConst64F(v *Value) bool { // match: (Const64F [val]) // cond: // result: (FMOVDconst [val]) @@ -9942,9 +9728,7 @@ func rewriteValueARM64_OpConst64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpConst8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpConst8(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVDconst [val]) @@ -9955,9 +9739,7 @@ func rewriteValueARM64_OpConst8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpConstBool(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpConstBool(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVDconst [b]) @@ -9968,9 +9750,7 @@ func rewriteValueARM64_OpConstBool(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpConstNil(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpConstNil(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVDconst [0]) @@ -9980,9 +9760,7 @@ func rewriteValueARM64_OpConstNil(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpConvert(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpConvert(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVDconvert x mem) @@ -9995,7 +9773,7 @@ func rewriteValueARM64_OpConvert(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCtz32(v *Value, config *Config) bool { +func rewriteValueARM64_OpCtz32(v *Value) bool { b := v.Block _ = b // match: (Ctz32 <t> x) @@ -10011,7 +9789,7 @@ func rewriteValueARM64_OpCtz32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCtz64(v *Value, config *Config) bool { +func rewriteValueARM64_OpCtz64(v *Value) bool { b := v.Block _ = b // match: (Ctz64 <t> x) @@ -10027,9 +9805,7 @@ func rewriteValueARM64_OpCtz64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt32Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt32Fto32(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (FCVTZSSW x) @@ -10040,9 +9816,7 @@ func rewriteValueARM64_OpCvt32Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt32Fto32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt32Fto32U(v *Value) bool { // match: (Cvt32Fto32U x) // cond: // result: (FCVTZUSW x) @@ -10053,9 +9827,7 @@ func rewriteValueARM64_OpCvt32Fto32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt32Fto64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt32Fto64(v *Value) bool { // match: (Cvt32Fto64 x) // cond: // result: (FCVTZSS x) @@ -10066,9 +9838,7 @@ func rewriteValueARM64_OpCvt32Fto64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt32Fto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt32Fto64F(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (FCVTSD x) @@ -10079,9 +9849,7 @@ func rewriteValueARM64_OpCvt32Fto64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt32Fto64U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt32Fto64U(v *Value) bool { // match: (Cvt32Fto64U x) // cond: // result: (FCVTZUS x) @@ -10092,9 +9860,7 @@ func rewriteValueARM64_OpCvt32Fto64U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt32Uto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt32Uto32F(v *Value) bool { // match: (Cvt32Uto32F x) // cond: // result: (UCVTFWS x) @@ -10105,9 +9871,7 @@ func rewriteValueARM64_OpCvt32Uto32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt32Uto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt32Uto64F(v *Value) bool { // match: (Cvt32Uto64F x) // cond: // result: (UCVTFWD x) @@ -10118,9 +9882,7 @@ func rewriteValueARM64_OpCvt32Uto64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt32to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt32to32F(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (SCVTFWS x) @@ -10131,9 +9893,7 @@ func rewriteValueARM64_OpCvt32to32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt32to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt32to64F(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (SCVTFWD x) @@ -10144,9 +9904,7 @@ func rewriteValueARM64_OpCvt32to64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt64Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt64Fto32(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (FCVTZSDW x) @@ -10157,9 +9915,7 @@ func rewriteValueARM64_OpCvt64Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt64Fto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt64Fto32F(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (FCVTDS x) @@ -10170,9 +9926,7 @@ func rewriteValueARM64_OpCvt64Fto32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt64Fto32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt64Fto32U(v *Value) bool { // match: (Cvt64Fto32U x) // cond: // result: (FCVTZUDW x) @@ -10183,9 +9937,7 @@ func rewriteValueARM64_OpCvt64Fto32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt64Fto64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt64Fto64(v *Value) bool { // match: (Cvt64Fto64 x) // cond: // result: (FCVTZSD x) @@ -10196,9 +9948,7 @@ func rewriteValueARM64_OpCvt64Fto64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt64Fto64U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt64Fto64U(v *Value) bool { // match: (Cvt64Fto64U x) // cond: // result: (FCVTZUD x) @@ -10209,9 +9959,7 @@ func rewriteValueARM64_OpCvt64Fto64U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt64Uto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt64Uto32F(v *Value) bool { // match: (Cvt64Uto32F x) // cond: // result: (UCVTFS x) @@ -10222,9 +9970,7 @@ func rewriteValueARM64_OpCvt64Uto32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt64Uto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt64Uto64F(v *Value) bool { // match: (Cvt64Uto64F x) // cond: // result: (UCVTFD x) @@ -10235,9 +9981,7 @@ func rewriteValueARM64_OpCvt64Uto64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt64to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt64to32F(v *Value) bool { // match: (Cvt64to32F x) // cond: // result: (SCVTFS x) @@ -10248,9 +9992,7 @@ func rewriteValueARM64_OpCvt64to32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpCvt64to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpCvt64to64F(v *Value) bool { // match: (Cvt64to64F x) // cond: // result: (SCVTFD x) @@ -10261,9 +10003,13 @@ func rewriteValueARM64_OpCvt64to64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpDiv16(v *Value, config *Config) bool { +func rewriteValueARM64_OpDiv16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16 x y) // cond: // result: (DIVW (SignExt16to32 x) (SignExt16to32 y)) @@ -10271,18 +10017,22 @@ func rewriteValueARM64_OpDiv16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64DIVW) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM64_OpDiv16u(v *Value, config *Config) bool { +func rewriteValueARM64_OpDiv16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16u x y) // cond: // result: (UDIVW (ZeroExt16to32 x) (ZeroExt16to32 y)) @@ -10290,18 +10040,16 @@ func rewriteValueARM64_OpDiv16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64UDIVW) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM64_OpDiv32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpDiv32(v *Value) bool { // match: (Div32 x y) // cond: // result: (DIVW x y) @@ -10314,9 +10062,7 @@ func rewriteValueARM64_OpDiv32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpDiv32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpDiv32F(v *Value) bool { // match: (Div32F x y) // cond: // result: (FDIVS x y) @@ -10329,9 +10075,7 @@ func rewriteValueARM64_OpDiv32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpDiv32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpDiv32u(v *Value) bool { // match: (Div32u x y) // cond: // result: (UDIVW x y) @@ -10344,9 +10088,7 @@ func rewriteValueARM64_OpDiv32u(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpDiv64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpDiv64(v *Value) bool { // match: (Div64 x y) // cond: // result: (DIV x y) @@ -10359,9 +10101,7 @@ func rewriteValueARM64_OpDiv64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpDiv64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpDiv64F(v *Value) bool { // match: (Div64F x y) // cond: // result: (FDIVD x y) @@ -10374,9 +10114,7 @@ func rewriteValueARM64_OpDiv64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpDiv64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpDiv64u(v *Value) bool { // match: (Div64u x y) // cond: // result: (UDIV x y) @@ -10389,9 +10127,13 @@ func rewriteValueARM64_OpDiv64u(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpDiv8(v *Value, config *Config) bool { +func rewriteValueARM64_OpDiv8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8 x y) // cond: // result: (DIVW (SignExt8to32 x) (SignExt8to32 y)) @@ -10399,18 +10141,22 @@ func rewriteValueARM64_OpDiv8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64DIVW) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM64_OpDiv8u(v *Value, config *Config) bool { +func rewriteValueARM64_OpDiv8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8u x y) // cond: // result: (UDIVW (ZeroExt8to32 x) (ZeroExt8to32 y)) @@ -10418,18 +10164,22 @@ func rewriteValueARM64_OpDiv8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64UDIVW) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM64_OpEq16(v *Value, config *Config) bool { +func rewriteValueARM64_OpEq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq16 x y) // cond: // result: (Equal (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -10438,17 +10188,17 @@ func rewriteValueARM64_OpEq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64Equal) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpEq32(v *Value, config *Config) bool { +func rewriteValueARM64_OpEq32(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -10465,7 +10215,7 @@ func rewriteValueARM64_OpEq32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpEq32F(v *Value, config *Config) bool { +func rewriteValueARM64_OpEq32F(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -10482,7 +10232,7 @@ func rewriteValueARM64_OpEq32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpEq64(v *Value, config *Config) bool { +func rewriteValueARM64_OpEq64(v *Value) bool { b := v.Block _ = b // match: (Eq64 x y) @@ -10499,7 +10249,7 @@ func rewriteValueARM64_OpEq64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpEq64F(v *Value, config *Config) bool { +func rewriteValueARM64_OpEq64F(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -10516,9 +10266,13 @@ func rewriteValueARM64_OpEq64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpEq8(v *Value, config *Config) bool { +func rewriteValueARM64_OpEq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq8 x y) // cond: // result: (Equal (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -10527,37 +10281,41 @@ func rewriteValueARM64_OpEq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64Equal) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpEqB(v *Value, config *Config) bool { +func rewriteValueARM64_OpEqB(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqB x y) // cond: - // result: (XOR (MOVDconst [1]) (XOR <config.fe.TypeBool()> x y)) + // result: (XOR (MOVDconst [1]) (XOR <fe.TypeBool()> x y)) for { x := v.Args[0] y := v.Args[1] v.reset(OpARM64XOR) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpARM64XOR, config.fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpARM64XOR, fe.TypeBool()) v1.AddArg(x) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM64_OpEqPtr(v *Value, config *Config) bool { +func rewriteValueARM64_OpEqPtr(v *Value) bool { b := v.Block _ = b // match: (EqPtr x y) @@ -10574,9 +10332,13 @@ func rewriteValueARM64_OpEqPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGeq16(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16 x y) // cond: // result: (GreaterEqual (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -10585,19 +10347,23 @@ func rewriteValueARM64_OpGeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64GreaterEqual) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpGeq16U(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16U x y) // cond: // result: (GreaterEqualU (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -10606,17 +10372,17 @@ func rewriteValueARM64_OpGeq16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64GreaterEqualU) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpGeq32(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq32(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -10633,7 +10399,7 @@ func rewriteValueARM64_OpGeq32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGeq32F(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq32F(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -10650,7 +10416,7 @@ func rewriteValueARM64_OpGeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGeq32U(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq32U(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -10667,7 +10433,7 @@ func rewriteValueARM64_OpGeq32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGeq64(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq64(v *Value) bool { b := v.Block _ = b // match: (Geq64 x y) @@ -10684,7 +10450,7 @@ func rewriteValueARM64_OpGeq64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGeq64F(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq64F(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -10701,7 +10467,7 @@ func rewriteValueARM64_OpGeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGeq64U(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq64U(v *Value) bool { b := v.Block _ = b // match: (Geq64U x y) @@ -10718,9 +10484,13 @@ func rewriteValueARM64_OpGeq64U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGeq8(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8 x y) // cond: // result: (GreaterEqual (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -10729,19 +10499,23 @@ func rewriteValueARM64_OpGeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64GreaterEqual) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpGeq8U(v *Value, config *Config) bool { +func rewriteValueARM64_OpGeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8U x y) // cond: // result: (GreaterEqualU (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -10750,19 +10524,17 @@ func rewriteValueARM64_OpGeq8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64GreaterEqualU) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpGetClosurePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -10771,9 +10543,13 @@ func rewriteValueARM64_OpGetClosurePtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGreater16(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16 x y) // cond: // result: (GreaterThan (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -10782,19 +10558,23 @@ func rewriteValueARM64_OpGreater16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64GreaterThan) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpGreater16U(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16U x y) // cond: // result: (GreaterThanU (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -10803,17 +10583,17 @@ func rewriteValueARM64_OpGreater16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64GreaterThanU) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpGreater32(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater32(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -10830,7 +10610,7 @@ func rewriteValueARM64_OpGreater32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGreater32F(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater32F(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -10847,7 +10627,7 @@ func rewriteValueARM64_OpGreater32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGreater32U(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater32U(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -10864,7 +10644,7 @@ func rewriteValueARM64_OpGreater32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGreater64(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater64(v *Value) bool { b := v.Block _ = b // match: (Greater64 x y) @@ -10881,7 +10661,7 @@ func rewriteValueARM64_OpGreater64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGreater64F(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater64F(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -10898,7 +10678,7 @@ func rewriteValueARM64_OpGreater64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGreater64U(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater64U(v *Value) bool { b := v.Block _ = b // match: (Greater64U x y) @@ -10915,9 +10695,13 @@ func rewriteValueARM64_OpGreater64U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpGreater8(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8 x y) // cond: // result: (GreaterThan (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -10926,19 +10710,23 @@ func rewriteValueARM64_OpGreater8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64GreaterThan) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpGreater8U(v *Value, config *Config) bool { +func rewriteValueARM64_OpGreater8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8U x y) // cond: // result: (GreaterThanU (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -10947,55 +10735,61 @@ func rewriteValueARM64_OpGreater8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64GreaterThanU) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpHmul32(v *Value, config *Config) bool { +func rewriteValueARM64_OpHmul32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul32 x y) // cond: - // result: (SRAconst (MULL <config.fe.TypeInt64()> x y) [32]) + // result: (SRAconst (MULL <fe.TypeInt64()> x y) [32]) for { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRAconst) v.AuxInt = 32 - v0 := b.NewValue0(v.Pos, OpARM64MULL, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MULL, fe.TypeInt64()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueARM64_OpHmul32u(v *Value, config *Config) bool { +func rewriteValueARM64_OpHmul32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul32u x y) // cond: - // result: (SRAconst (UMULL <config.fe.TypeUInt64()> x y) [32]) + // result: (SRAconst (UMULL <fe.TypeUInt64()> x y) [32]) for { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRAconst) v.AuxInt = 32 - v0 := b.NewValue0(v.Pos, OpARM64UMULL, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64UMULL, fe.TypeUInt64()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueARM64_OpHmul64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpHmul64(v *Value) bool { // match: (Hmul64 x y) // cond: // result: (MULH x y) @@ -11008,9 +10802,7 @@ func rewriteValueARM64_OpHmul64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpHmul64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpHmul64u(v *Value) bool { // match: (Hmul64u x y) // cond: // result: (UMULH x y) @@ -11023,9 +10815,7 @@ func rewriteValueARM64_OpHmul64u(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpInterCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpInterCall(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -11040,7 +10830,7 @@ func rewriteValueARM64_OpInterCall(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpIsInBounds(v *Value, config *Config) bool { +func rewriteValueARM64_OpIsInBounds(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -11057,7 +10847,7 @@ func rewriteValueARM64_OpIsInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpIsNonNil(v *Value, config *Config) bool { +func rewriteValueARM64_OpIsNonNil(v *Value) bool { b := v.Block _ = b // match: (IsNonNil ptr) @@ -11073,7 +10863,7 @@ func rewriteValueARM64_OpIsNonNil(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpIsSliceInBounds(v *Value, config *Config) bool { +func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -11090,9 +10880,13 @@ func rewriteValueARM64_OpIsSliceInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLeq16(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16 x y) // cond: // result: (LessEqual (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -11101,19 +10895,23 @@ func rewriteValueARM64_OpLeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64LessEqual) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpLeq16U(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16U x y) // cond: // result: (LessEqualU (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -11122,17 +10920,17 @@ func rewriteValueARM64_OpLeq16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64LessEqualU) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpLeq32(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq32(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -11149,7 +10947,7 @@ func rewriteValueARM64_OpLeq32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLeq32F(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq32F(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -11166,7 +10964,7 @@ func rewriteValueARM64_OpLeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLeq32U(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq32U(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -11183,7 +10981,7 @@ func rewriteValueARM64_OpLeq32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLeq64(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq64(v *Value) bool { b := v.Block _ = b // match: (Leq64 x y) @@ -11200,7 +10998,7 @@ func rewriteValueARM64_OpLeq64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLeq64F(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq64F(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -11217,7 +11015,7 @@ func rewriteValueARM64_OpLeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLeq64U(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq64U(v *Value) bool { b := v.Block _ = b // match: (Leq64U x y) @@ -11234,9 +11032,13 @@ func rewriteValueARM64_OpLeq64U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLeq8(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8 x y) // cond: // result: (LessEqual (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -11245,19 +11047,23 @@ func rewriteValueARM64_OpLeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64LessEqual) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpLeq8U(v *Value, config *Config) bool { +func rewriteValueARM64_OpLeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8U x y) // cond: // result: (LessEqualU (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -11266,19 +11072,23 @@ func rewriteValueARM64_OpLeq8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64LessEqualU) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpLess16(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16 x y) // cond: // result: (LessThan (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -11287,19 +11097,23 @@ func rewriteValueARM64_OpLess16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64LessThan) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpLess16U(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16U x y) // cond: // result: (LessThanU (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -11308,17 +11122,17 @@ func rewriteValueARM64_OpLess16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64LessThanU) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpLess32(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess32(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -11335,7 +11149,7 @@ func rewriteValueARM64_OpLess32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLess32F(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess32F(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -11352,7 +11166,7 @@ func rewriteValueARM64_OpLess32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLess32U(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess32U(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -11369,7 +11183,7 @@ func rewriteValueARM64_OpLess32U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLess64(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess64(v *Value) bool { b := v.Block _ = b // match: (Less64 x y) @@ -11386,7 +11200,7 @@ func rewriteValueARM64_OpLess64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLess64F(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess64F(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -11403,7 +11217,7 @@ func rewriteValueARM64_OpLess64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLess64U(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess64U(v *Value) bool { b := v.Block _ = b // match: (Less64U x y) @@ -11420,9 +11234,13 @@ func rewriteValueARM64_OpLess64U(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLess8(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8 x y) // cond: // result: (LessThan (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -11431,19 +11249,23 @@ func rewriteValueARM64_OpLess8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64LessThan) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpLess8U(v *Value, config *Config) bool { +func rewriteValueARM64_OpLess8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8U x y) // cond: // result: (LessThanU (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -11452,19 +11274,17 @@ func rewriteValueARM64_OpLess8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64LessThanU) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpLoad(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpLoad(v *Value) bool { // match: (Load <t> ptr mem) // cond: t.IsBoolean() // result: (MOVBUload ptr mem) @@ -11617,9 +11437,13 @@ func rewriteValueARM64_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpLsh16x16(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x16 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y))) @@ -11630,7 +11454,7 @@ func rewriteValueARM64_OpLsh16x16(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -11639,16 +11463,20 @@ func rewriteValueARM64_OpLsh16x16(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh16x32(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x32 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y))) @@ -11659,7 +11487,7 @@ func rewriteValueARM64_OpLsh16x32(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -11668,14 +11496,14 @@ func rewriteValueARM64_OpLsh16x32(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh16x64(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh16x64(v *Value) bool { b := v.Block _ = b // match: (Lsh16x64 x (MOVDconst [c])) @@ -11734,9 +11562,13 @@ func rewriteValueARM64_OpLsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLsh16x8(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x8 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y))) @@ -11747,7 +11579,7 @@ func rewriteValueARM64_OpLsh16x8(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -11756,16 +11588,20 @@ func rewriteValueARM64_OpLsh16x8(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh32x16(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x16 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y))) @@ -11776,7 +11612,7 @@ func rewriteValueARM64_OpLsh32x16(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -11785,16 +11621,20 @@ func rewriteValueARM64_OpLsh32x16(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh32x32(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh32x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x32 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y))) @@ -11805,7 +11645,7 @@ func rewriteValueARM64_OpLsh32x32(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -11814,14 +11654,14 @@ func rewriteValueARM64_OpLsh32x32(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh32x64(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh32x64(v *Value) bool { b := v.Block _ = b // match: (Lsh32x64 x (MOVDconst [c])) @@ -11880,9 +11720,13 @@ func rewriteValueARM64_OpLsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLsh32x8(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x8 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y))) @@ -11893,7 +11737,7 @@ func rewriteValueARM64_OpLsh32x8(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -11902,16 +11746,20 @@ func rewriteValueARM64_OpLsh32x8(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh64x16(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x16 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y))) @@ -11922,7 +11770,7 @@ func rewriteValueARM64_OpLsh64x16(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -11931,16 +11779,20 @@ func rewriteValueARM64_OpLsh64x16(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh64x32(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh64x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x32 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y))) @@ -11951,7 +11803,7 @@ func rewriteValueARM64_OpLsh64x32(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -11960,14 +11812,14 @@ func rewriteValueARM64_OpLsh64x32(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh64x64(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh64x64(v *Value) bool { b := v.Block _ = b // match: (Lsh64x64 x (MOVDconst [c])) @@ -12026,9 +11878,13 @@ func rewriteValueARM64_OpLsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLsh64x8(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x8 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y))) @@ -12039,7 +11895,7 @@ func rewriteValueARM64_OpLsh64x8(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -12048,16 +11904,20 @@ func rewriteValueARM64_OpLsh64x8(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh8x16(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x16 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y))) @@ -12068,7 +11928,7 @@ func rewriteValueARM64_OpLsh8x16(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -12077,16 +11937,20 @@ func rewriteValueARM64_OpLsh8x16(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh8x32(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x32 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y))) @@ -12097,7 +11961,7 @@ func rewriteValueARM64_OpLsh8x32(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -12106,14 +11970,14 @@ func rewriteValueARM64_OpLsh8x32(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpLsh8x64(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh8x64(v *Value) bool { b := v.Block _ = b // match: (Lsh8x64 x (MOVDconst [c])) @@ -12172,9 +12036,13 @@ func rewriteValueARM64_OpLsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpLsh8x8(v *Value, config *Config) bool { +func rewriteValueARM64_OpLsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x8 <t> x y) // cond: // result: (CSELULT (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y))) @@ -12185,7 +12053,7 @@ func rewriteValueARM64_OpLsh8x8(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -12194,16 +12062,20 @@ func rewriteValueARM64_OpLsh8x8(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpMod16(v *Value, config *Config) bool { +func rewriteValueARM64_OpMod16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16 x y) // cond: // result: (MODW (SignExt16to32 x) (SignExt16to32 y)) @@ -12211,18 +12083,22 @@ func rewriteValueARM64_OpMod16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64MODW) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM64_OpMod16u(v *Value, config *Config) bool { +func rewriteValueARM64_OpMod16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16u x y) // cond: // result: (UMODW (ZeroExt16to32 x) (ZeroExt16to32 y)) @@ -12230,18 +12106,16 @@ func rewriteValueARM64_OpMod16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64UMODW) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM64_OpMod32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMod32(v *Value) bool { // match: (Mod32 x y) // cond: // result: (MODW x y) @@ -12254,9 +12128,7 @@ func rewriteValueARM64_OpMod32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpMod32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMod32u(v *Value) bool { // match: (Mod32u x y) // cond: // result: (UMODW x y) @@ -12269,9 +12141,7 @@ func rewriteValueARM64_OpMod32u(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpMod64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMod64(v *Value) bool { // match: (Mod64 x y) // cond: // result: (MOD x y) @@ -12284,9 +12154,7 @@ func rewriteValueARM64_OpMod64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpMod64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMod64u(v *Value) bool { // match: (Mod64u x y) // cond: // result: (UMOD x y) @@ -12299,9 +12167,13 @@ func rewriteValueARM64_OpMod64u(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpMod8(v *Value, config *Config) bool { +func rewriteValueARM64_OpMod8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8 x y) // cond: // result: (MODW (SignExt8to32 x) (SignExt8to32 y)) @@ -12309,18 +12181,22 @@ func rewriteValueARM64_OpMod8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64MODW) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM64_OpMod8u(v *Value, config *Config) bool { +func rewriteValueARM64_OpMod8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8u x y) // cond: // result: (UMODW (ZeroExt8to32 x) (ZeroExt8to32 y)) @@ -12328,18 +12204,22 @@ func rewriteValueARM64_OpMod8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64UMODW) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueARM64_OpMove(v *Value, config *Config) bool { +func rewriteValueARM64_OpMove(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Move [0] _ _ mem) // cond: // result: mem @@ -12365,7 +12245,7 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpARM64MOVBstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, fe.TypeUInt8()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -12384,7 +12264,7 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpARM64MOVHstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, fe.TypeUInt16()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -12403,7 +12283,7 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpARM64MOVWstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -12422,7 +12302,7 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpARM64MOVDstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVDload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -12442,14 +12322,14 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { v.reset(OpARM64MOVBstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, fe.TypeUInt8()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, fe.TypeUInt16()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -12470,14 +12350,14 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { v.reset(OpARM64MOVBstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, fe.TypeUInt8()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -12498,14 +12378,14 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { v.reset(OpARM64MOVHstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, fe.TypeUInt16()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -12526,7 +12406,7 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { v.reset(OpARM64MOVBstore) v.AuxInt = 6 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, fe.TypeUInt8()) v0.AuxInt = 6 v0.AddArg(src) v0.AddArg(mem) @@ -12534,14 +12414,14 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, TypeMem) v1.AuxInt = 4 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, fe.TypeUInt16()) v2.AuxInt = 4 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpARM64MOVWUload, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -12563,14 +12443,14 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { v.reset(OpARM64MOVWstore) v.AuxInt = 8 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32()) v0.AuxInt = 8 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARM64MOVDload, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -12591,14 +12471,14 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { v.reset(OpARM64MOVDstore) v.AuxInt = 8 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVDload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64()) v0.AuxInt = 8 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARM64MOVDload, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -12619,7 +12499,7 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { v.reset(OpARM64MOVDstore) v.AuxInt = 16 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpARM64MOVDload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64()) v0.AuxInt = 16 v0.AddArg(src) v0.AddArg(mem) @@ -12627,14 +12507,14 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem) v1.AuxInt = 8 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpARM64MOVDload, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64()) v2.AuxInt = 8 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpARM64MOVDload, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -12713,9 +12593,7 @@ func rewriteValueARM64_OpMove(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpMul16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMul16(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULW x y) @@ -12728,9 +12606,7 @@ func rewriteValueARM64_OpMul16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpMul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMul32(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULW x y) @@ -12743,9 +12619,7 @@ func rewriteValueARM64_OpMul32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpMul32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMul32F(v *Value) bool { // match: (Mul32F x y) // cond: // result: (FMULS x y) @@ -12758,9 +12632,7 @@ func rewriteValueARM64_OpMul32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpMul64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMul64(v *Value) bool { // match: (Mul64 x y) // cond: // result: (MUL x y) @@ -12773,9 +12645,7 @@ func rewriteValueARM64_OpMul64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpMul64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMul64F(v *Value) bool { // match: (Mul64F x y) // cond: // result: (FMULD x y) @@ -12788,9 +12658,7 @@ func rewriteValueARM64_OpMul64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpMul8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpMul8(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULW x y) @@ -12803,9 +12671,7 @@ func rewriteValueARM64_OpMul8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeg16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpNeg16(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEG x) @@ -12816,9 +12682,7 @@ func rewriteValueARM64_OpNeg16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeg32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpNeg32(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEG x) @@ -12829,9 +12693,7 @@ func rewriteValueARM64_OpNeg32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeg32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpNeg32F(v *Value) bool { // match: (Neg32F x) // cond: // result: (FNEGS x) @@ -12842,9 +12704,7 @@ func rewriteValueARM64_OpNeg32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeg64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpNeg64(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEG x) @@ -12855,9 +12715,7 @@ func rewriteValueARM64_OpNeg64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeg64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpNeg64F(v *Value) bool { // match: (Neg64F x) // cond: // result: (FNEGD x) @@ -12868,9 +12726,7 @@ func rewriteValueARM64_OpNeg64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeg8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpNeg8(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEG x) @@ -12881,9 +12737,13 @@ func rewriteValueARM64_OpNeg8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeq16(v *Value, config *Config) bool { +func rewriteValueARM64_OpNeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq16 x y) // cond: // result: (NotEqual (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -12892,17 +12752,17 @@ func rewriteValueARM64_OpNeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64NotEqual) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpNeq32(v *Value, config *Config) bool { +func rewriteValueARM64_OpNeq32(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -12919,7 +12779,7 @@ func rewriteValueARM64_OpNeq32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeq32F(v *Value, config *Config) bool { +func rewriteValueARM64_OpNeq32F(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -12936,7 +12796,7 @@ func rewriteValueARM64_OpNeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeq64(v *Value, config *Config) bool { +func rewriteValueARM64_OpNeq64(v *Value) bool { b := v.Block _ = b // match: (Neq64 x y) @@ -12953,7 +12813,7 @@ func rewriteValueARM64_OpNeq64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeq64F(v *Value, config *Config) bool { +func rewriteValueARM64_OpNeq64F(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -12970,9 +12830,13 @@ func rewriteValueARM64_OpNeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeq8(v *Value, config *Config) bool { +func rewriteValueARM64_OpNeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq8 x y) // cond: // result: (NotEqual (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -12981,19 +12845,17 @@ func rewriteValueARM64_OpNeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64NotEqual) v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueARM64_OpNeqB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpNeqB(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -13006,7 +12868,7 @@ func rewriteValueARM64_OpNeqB(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNeqPtr(v *Value, config *Config) bool { +func rewriteValueARM64_OpNeqPtr(v *Value) bool { b := v.Block _ = b // match: (NeqPtr x y) @@ -13023,9 +12885,7 @@ func rewriteValueARM64_OpNeqPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNilCheck(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpNilCheck(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -13038,25 +12898,27 @@ func rewriteValueARM64_OpNilCheck(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpNot(v *Value, config *Config) bool { +func rewriteValueARM64_OpNot(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Not x) // cond: // result: (XOR (MOVDconst [1]) x) for { x := v.Args[0] v.reset(OpARM64XOR) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) v.AddArg(x) return true } } -func rewriteValueARM64_OpOffPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpOffPtr(v *Value) bool { // match: (OffPtr [off] ptr:(SP)) // cond: // result: (MOVDaddr [off] ptr) @@ -13083,9 +12945,7 @@ func rewriteValueARM64_OpOffPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpOr16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpOr16(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -13098,9 +12958,7 @@ func rewriteValueARM64_OpOr16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpOr32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpOr32(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -13113,9 +12971,7 @@ func rewriteValueARM64_OpOr32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpOr64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpOr64(v *Value) bool { // match: (Or64 x y) // cond: // result: (OR x y) @@ -13128,9 +12984,7 @@ func rewriteValueARM64_OpOr64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpOr8(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -13143,9 +12997,7 @@ func rewriteValueARM64_OpOr8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpOrB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpOrB(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -13158,9 +13010,7 @@ func rewriteValueARM64_OpOrB(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpRound32F(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -13172,9 +13022,7 @@ func rewriteValueARM64_OpRound32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpRound64F(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -13186,9 +13034,13 @@ func rewriteValueARM64_OpRound64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh16Ux16(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh16Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux16 <t> x y) // cond: // result: (CSELULT (SRL <t> (ZeroExt16to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y))) @@ -13198,10 +13050,10 @@ func rewriteValueARM64_OpRsh16Ux16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -13210,16 +13062,20 @@ func rewriteValueARM64_OpRsh16Ux16(v *Value, config *Config) bool { v.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueARM64_OpRsh16Ux32(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh16Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux32 <t> x y) // cond: // result: (CSELULT (SRL <t> (ZeroExt16to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y))) @@ -13229,10 +13085,10 @@ func rewriteValueARM64_OpRsh16Ux32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -13241,16 +13097,20 @@ func rewriteValueARM64_OpRsh16Ux32(v *Value, config *Config) bool { v.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueARM64_OpRsh16Ux64(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh16Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux64 x (MOVDconst [c])) // cond: uint64(c) < 16 // result: (SRLconst (ZeroExt16to64 x) [c]) @@ -13266,7 +13126,7 @@ func rewriteValueARM64_OpRsh16Ux64(v *Value, config *Config) bool { } v.reset(OpARM64SRLconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) return true @@ -13296,7 +13156,7 @@ func rewriteValueARM64_OpRsh16Ux64(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -13311,9 +13171,13 @@ func rewriteValueARM64_OpRsh16Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh16Ux8(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh16Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux8 <t> x y) // cond: // result: (CSELULT (SRL <t> (ZeroExt16to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y))) @@ -13323,10 +13187,10 @@ func rewriteValueARM64_OpRsh16Ux8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -13335,16 +13199,20 @@ func rewriteValueARM64_OpRsh16Ux8(v *Value, config *Config) bool { v.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueARM64_OpRsh16x16(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x16 x y) // cond: // result: (SRA (SignExt16to64 x) (CSELULT <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y)))) @@ -13352,11 +13220,11 @@ func rewriteValueARM64_OpRsh16x16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -13364,7 +13232,7 @@ func rewriteValueARM64_OpRsh16x16(v *Value, config *Config) bool { v1.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -13372,9 +13240,13 @@ func rewriteValueARM64_OpRsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh16x32(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x32 x y) // cond: // result: (SRA (SignExt16to64 x) (CSELULT <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y)))) @@ -13382,11 +13254,11 @@ func rewriteValueARM64_OpRsh16x32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -13394,7 +13266,7 @@ func rewriteValueARM64_OpRsh16x32(v *Value, config *Config) bool { v1.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -13402,9 +13274,13 @@ func rewriteValueARM64_OpRsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh16x64(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x64 x (MOVDconst [c])) // cond: uint64(c) < 16 // result: (SRAconst (SignExt16to64 x) [c]) @@ -13420,7 +13296,7 @@ func rewriteValueARM64_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpARM64SRAconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) return true @@ -13440,7 +13316,7 @@ func rewriteValueARM64_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpARM64SRAconst) v.AuxInt = 63 - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) return true @@ -13452,7 +13328,7 @@ func rewriteValueARM64_OpRsh16x64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) @@ -13468,9 +13344,13 @@ func rewriteValueARM64_OpRsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh16x8(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x8 x y) // cond: // result: (SRA (SignExt16to64 x) (CSELULT <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y)))) @@ -13478,11 +13358,11 @@ func rewriteValueARM64_OpRsh16x8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -13490,7 +13370,7 @@ func rewriteValueARM64_OpRsh16x8(v *Value, config *Config) bool { v1.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -13498,9 +13378,13 @@ func rewriteValueARM64_OpRsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh32Ux16(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh32Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux16 <t> x y) // cond: // result: (CSELULT (SRL <t> (ZeroExt32to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y))) @@ -13510,10 +13394,10 @@ func rewriteValueARM64_OpRsh32Ux16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -13522,16 +13406,20 @@ func rewriteValueARM64_OpRsh32Ux16(v *Value, config *Config) bool { v.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueARM64_OpRsh32Ux32(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh32Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux32 <t> x y) // cond: // result: (CSELULT (SRL <t> (ZeroExt32to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y))) @@ -13541,10 +13429,10 @@ func rewriteValueARM64_OpRsh32Ux32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -13553,16 +13441,20 @@ func rewriteValueARM64_OpRsh32Ux32(v *Value, config *Config) bool { v.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueARM64_OpRsh32Ux64(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh32Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux64 x (MOVDconst [c])) // cond: uint64(c) < 32 // result: (SRLconst (ZeroExt32to64 x) [c]) @@ -13578,7 +13470,7 @@ func rewriteValueARM64_OpRsh32Ux64(v *Value, config *Config) bool { } v.reset(OpARM64SRLconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) return true @@ -13608,7 +13500,7 @@ func rewriteValueARM64_OpRsh32Ux64(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -13623,9 +13515,13 @@ func rewriteValueARM64_OpRsh32Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh32Ux8(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh32Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux8 <t> x y) // cond: // result: (CSELULT (SRL <t> (ZeroExt32to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y))) @@ -13635,10 +13531,10 @@ func rewriteValueARM64_OpRsh32Ux8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -13647,16 +13543,20 @@ func rewriteValueARM64_OpRsh32Ux8(v *Value, config *Config) bool { v.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueARM64_OpRsh32x16(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x16 x y) // cond: // result: (SRA (SignExt32to64 x) (CSELULT <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y)))) @@ -13664,11 +13564,11 @@ func rewriteValueARM64_OpRsh32x16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -13676,7 +13576,7 @@ func rewriteValueARM64_OpRsh32x16(v *Value, config *Config) bool { v1.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -13684,9 +13584,13 @@ func rewriteValueARM64_OpRsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh32x32(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh32x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x32 x y) // cond: // result: (SRA (SignExt32to64 x) (CSELULT <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y)))) @@ -13694,11 +13598,11 @@ func rewriteValueARM64_OpRsh32x32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -13706,7 +13610,7 @@ func rewriteValueARM64_OpRsh32x32(v *Value, config *Config) bool { v1.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -13714,9 +13618,13 @@ func rewriteValueARM64_OpRsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh32x64(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh32x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x64 x (MOVDconst [c])) // cond: uint64(c) < 32 // result: (SRAconst (SignExt32to64 x) [c]) @@ -13732,7 +13640,7 @@ func rewriteValueARM64_OpRsh32x64(v *Value, config *Config) bool { } v.reset(OpARM64SRAconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) return true @@ -13752,7 +13660,7 @@ func rewriteValueARM64_OpRsh32x64(v *Value, config *Config) bool { } v.reset(OpARM64SRAconst) v.AuxInt = 63 - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) return true @@ -13764,7 +13672,7 @@ func rewriteValueARM64_OpRsh32x64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) @@ -13780,9 +13688,13 @@ func rewriteValueARM64_OpRsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh32x8(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x8 x y) // cond: // result: (SRA (SignExt32to64 x) (CSELULT <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y)))) @@ -13790,11 +13702,11 @@ func rewriteValueARM64_OpRsh32x8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -13802,7 +13714,7 @@ func rewriteValueARM64_OpRsh32x8(v *Value, config *Config) bool { v1.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -13810,9 +13722,13 @@ func rewriteValueARM64_OpRsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh64Ux16(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh64Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux16 <t> x y) // cond: // result: (CSELULT (SRL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y))) @@ -13823,7 +13739,7 @@ func rewriteValueARM64_OpRsh64Ux16(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -13832,16 +13748,20 @@ func rewriteValueARM64_OpRsh64Ux16(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpRsh64Ux32(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh64Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux32 <t> x y) // cond: // result: (CSELULT (SRL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y))) @@ -13852,7 +13772,7 @@ func rewriteValueARM64_OpRsh64Ux32(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -13861,14 +13781,14 @@ func rewriteValueARM64_OpRsh64Ux32(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpRsh64Ux64(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh64Ux64(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux64 x (MOVDconst [c])) @@ -13927,9 +13847,13 @@ func rewriteValueARM64_OpRsh64Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh64Ux8(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh64Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux8 <t> x y) // cond: // result: (CSELULT (SRL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y))) @@ -13940,7 +13864,7 @@ func rewriteValueARM64_OpRsh64Ux8(v *Value, config *Config) bool { v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) @@ -13949,16 +13873,20 @@ func rewriteValueARM64_OpRsh64Ux8(v *Value, config *Config) bool { v.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueARM64_OpRsh64x16(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x16 x y) // cond: // result: (SRA x (CSELULT <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y)))) @@ -13968,7 +13896,7 @@ func rewriteValueARM64_OpRsh64x16(v *Value, config *Config) bool { v.reset(OpARM64SRA) v.AddArg(x) v0 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v2 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -13976,7 +13904,7 @@ func rewriteValueARM64_OpRsh64x16(v *Value, config *Config) bool { v0.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v0.AddArg(v3) @@ -13984,9 +13912,13 @@ func rewriteValueARM64_OpRsh64x16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh64x32(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh64x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x32 x y) // cond: // result: (SRA x (CSELULT <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y)))) @@ -13996,7 +13928,7 @@ func rewriteValueARM64_OpRsh64x32(v *Value, config *Config) bool { v.reset(OpARM64SRA) v.AddArg(x) v0 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v2 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -14004,7 +13936,7 @@ func rewriteValueARM64_OpRsh64x32(v *Value, config *Config) bool { v0.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v0.AddArg(v3) @@ -14012,7 +13944,7 @@ func rewriteValueARM64_OpRsh64x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh64x64(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh64x64(v *Value) bool { b := v.Block _ = b // match: (Rsh64x64 x (MOVDconst [c])) @@ -14072,9 +14004,13 @@ func rewriteValueARM64_OpRsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh64x8(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x8 x y) // cond: // result: (SRA x (CSELULT <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y)))) @@ -14084,7 +14020,7 @@ func rewriteValueARM64_OpRsh64x8(v *Value, config *Config) bool { v.reset(OpARM64SRA) v.AddArg(x) v0 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(y) v0.AddArg(v1) v2 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -14092,7 +14028,7 @@ func rewriteValueARM64_OpRsh64x8(v *Value, config *Config) bool { v0.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v3.AuxInt = 64 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v0.AddArg(v3) @@ -14100,9 +14036,13 @@ func rewriteValueARM64_OpRsh64x8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh8Ux16(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh8Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux16 <t> x y) // cond: // result: (CSELULT (SRL <t> (ZeroExt8to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y))) @@ -14112,10 +14052,10 @@ func rewriteValueARM64_OpRsh8Ux16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -14124,16 +14064,20 @@ func rewriteValueARM64_OpRsh8Ux16(v *Value, config *Config) bool { v.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueARM64_OpRsh8Ux32(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh8Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux32 <t> x y) // cond: // result: (CSELULT (SRL <t> (ZeroExt8to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y))) @@ -14143,10 +14087,10 @@ func rewriteValueARM64_OpRsh8Ux32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -14155,16 +14099,20 @@ func rewriteValueARM64_OpRsh8Ux32(v *Value, config *Config) bool { v.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueARM64_OpRsh8Ux64(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh8Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux64 x (MOVDconst [c])) // cond: uint64(c) < 8 // result: (SRLconst (ZeroExt8to64 x) [c]) @@ -14180,7 +14128,7 @@ func rewriteValueARM64_OpRsh8Ux64(v *Value, config *Config) bool { } v.reset(OpARM64SRLconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) return true @@ -14210,7 +14158,7 @@ func rewriteValueARM64_OpRsh8Ux64(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -14225,9 +14173,13 @@ func rewriteValueARM64_OpRsh8Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh8Ux8(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh8Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux8 <t> x y) // cond: // result: (CSELULT (SRL <t> (ZeroExt8to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y))) @@ -14237,10 +14189,10 @@ func rewriteValueARM64_OpRsh8Ux8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpARM64CSELULT) v0 := b.NewValue0(v.Pos, OpARM64SRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -14249,16 +14201,20 @@ func rewriteValueARM64_OpRsh8Ux8(v *Value, config *Config) bool { v.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueARM64_OpRsh8x16(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x16 x y) // cond: // result: (SRA (SignExt8to64 x) (CSELULT <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y)))) @@ -14266,11 +14222,11 @@ func rewriteValueARM64_OpRsh8x16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -14278,7 +14234,7 @@ func rewriteValueARM64_OpRsh8x16(v *Value, config *Config) bool { v1.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -14286,9 +14242,13 @@ func rewriteValueARM64_OpRsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh8x32(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x32 x y) // cond: // result: (SRA (SignExt8to64 x) (CSELULT <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y)))) @@ -14296,11 +14256,11 @@ func rewriteValueARM64_OpRsh8x32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -14308,7 +14268,7 @@ func rewriteValueARM64_OpRsh8x32(v *Value, config *Config) bool { v1.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -14316,9 +14276,13 @@ func rewriteValueARM64_OpRsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh8x64(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x64 x (MOVDconst [c])) // cond: uint64(c) < 8 // result: (SRAconst (SignExt8to64 x) [c]) @@ -14334,7 +14298,7 @@ func rewriteValueARM64_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpARM64SRAconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) return true @@ -14354,7 +14318,7 @@ func rewriteValueARM64_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpARM64SRAconst) v.AuxInt = 63 - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) return true @@ -14366,7 +14330,7 @@ func rewriteValueARM64_OpRsh8x64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) @@ -14382,9 +14346,13 @@ func rewriteValueARM64_OpRsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpRsh8x8(v *Value, config *Config) bool { +func rewriteValueARM64_OpRsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x8 x y) // cond: // result: (SRA (SignExt8to64 x) (CSELULT <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y)))) @@ -14392,11 +14360,11 @@ func rewriteValueARM64_OpRsh8x8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpARM64SRA) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpConst64, y.Type) @@ -14404,7 +14372,7 @@ func rewriteValueARM64_OpRsh8x8(v *Value, config *Config) bool { v1.AddArg(v3) v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags) v4.AuxInt = 64 - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -14412,9 +14380,7 @@ func rewriteValueARM64_OpRsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSignExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSignExt16to32(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -14425,9 +14391,7 @@ func rewriteValueARM64_OpSignExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSignExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSignExt16to64(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVHreg x) @@ -14438,9 +14402,7 @@ func rewriteValueARM64_OpSignExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSignExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSignExt32to64(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVWreg x) @@ -14451,9 +14413,7 @@ func rewriteValueARM64_OpSignExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSignExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSignExt8to16(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -14464,9 +14424,7 @@ func rewriteValueARM64_OpSignExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSignExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSignExt8to32(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -14477,9 +14435,7 @@ func rewriteValueARM64_OpSignExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSignExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSignExt8to64(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBreg x) @@ -14490,7 +14446,7 @@ func rewriteValueARM64_OpSignExt8to64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSlicemask(v *Value, config *Config) bool { +func rewriteValueARM64_OpSlicemask(v *Value) bool { b := v.Block _ = b // match: (Slicemask <t> x) @@ -14507,9 +14463,7 @@ func rewriteValueARM64_OpSlicemask(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSqrt(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSqrt(v *Value) bool { // match: (Sqrt x) // cond: // result: (FSQRTD x) @@ -14520,9 +14474,7 @@ func rewriteValueARM64_OpSqrt(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpStaticCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpStaticCall(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -14537,9 +14489,7 @@ func rewriteValueARM64_OpStaticCall(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpStore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpStore(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 1 // result: (MOVBstore ptr val mem) @@ -14644,9 +14594,7 @@ func rewriteValueARM64_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpSub16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSub16(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUB x y) @@ -14659,9 +14607,7 @@ func rewriteValueARM64_OpSub16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSub32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSub32(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUB x y) @@ -14674,9 +14620,7 @@ func rewriteValueARM64_OpSub32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSub32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSub32F(v *Value) bool { // match: (Sub32F x y) // cond: // result: (FSUBS x y) @@ -14689,9 +14633,7 @@ func rewriteValueARM64_OpSub32F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSub64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSub64(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUB x y) @@ -14704,9 +14646,7 @@ func rewriteValueARM64_OpSub64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSub64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSub64F(v *Value) bool { // match: (Sub64F x y) // cond: // result: (FSUBD x y) @@ -14719,9 +14659,7 @@ func rewriteValueARM64_OpSub64F(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSub8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSub8(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUB x y) @@ -14734,9 +14672,7 @@ func rewriteValueARM64_OpSub8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpSubPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpSubPtr(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -14749,9 +14685,7 @@ func rewriteValueARM64_OpSubPtr(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpTrunc16to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpTrunc16to8(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -14763,9 +14697,7 @@ func rewriteValueARM64_OpTrunc16to8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpTrunc32to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpTrunc32to16(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -14777,9 +14709,7 @@ func rewriteValueARM64_OpTrunc32to16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpTrunc32to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpTrunc32to8(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -14791,9 +14721,7 @@ func rewriteValueARM64_OpTrunc32to8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpTrunc64to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpTrunc64to16(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: x @@ -14805,9 +14733,7 @@ func rewriteValueARM64_OpTrunc64to16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpTrunc64to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpTrunc64to32(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: x @@ -14819,9 +14745,7 @@ func rewriteValueARM64_OpTrunc64to32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpTrunc64to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpTrunc64to8(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: x @@ -14833,9 +14757,7 @@ func rewriteValueARM64_OpTrunc64to8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpXor16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpXor16(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -14848,9 +14770,7 @@ func rewriteValueARM64_OpXor16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpXor32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpXor32(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -14863,9 +14783,7 @@ func rewriteValueARM64_OpXor32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpXor64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpXor64(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XOR x y) @@ -14878,9 +14796,7 @@ func rewriteValueARM64_OpXor64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpXor8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpXor8(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -14893,9 +14809,13 @@ func rewriteValueARM64_OpXor8(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpZero(v *Value, config *Config) bool { +func rewriteValueARM64_OpZero(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Zero [0] _ mem) // cond: // result: mem @@ -14920,7 +14840,7 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { mem := v.Args[1] v.reset(OpARM64MOVBstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -14937,7 +14857,7 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { mem := v.Args[1] v.reset(OpARM64MOVHstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -14954,7 +14874,7 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { mem := v.Args[1] v.reset(OpARM64MOVWstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -14971,7 +14891,7 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { mem := v.Args[1] v.reset(OpARM64MOVDstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -14989,12 +14909,12 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { v.reset(OpARM64MOVBstore) v.AuxInt = 2 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, TypeMem) v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -15013,12 +14933,12 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { v.reset(OpARM64MOVBstore) v.AuxInt = 4 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem) v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -15037,12 +14957,12 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { v.reset(OpARM64MOVHstore) v.AuxInt = 4 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem) v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -15061,18 +14981,18 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { v.reset(OpARM64MOVBstore) v.AuxInt = 6 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, TypeMem) v1.AuxInt = 4 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem) v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -15092,12 +15012,12 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { v.reset(OpARM64MOVWstore) v.AuxInt = 8 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem) v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -15116,12 +15036,12 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { v.reset(OpARM64MOVDstore) v.AuxInt = 8 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem) v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -15140,18 +15060,18 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { v.reset(OpARM64MOVDstore) v.AuxInt = 16 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem) v1.AuxInt = 8 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem) v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -15219,9 +15139,7 @@ func rewriteValueARM64_OpZero(v *Value, config *Config) bool { } return false } -func rewriteValueARM64_OpZeroExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpZeroExt16to32(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHUreg x) @@ -15232,9 +15150,7 @@ func rewriteValueARM64_OpZeroExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpZeroExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpZeroExt16to64(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVHUreg x) @@ -15245,9 +15161,7 @@ func rewriteValueARM64_OpZeroExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpZeroExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpZeroExt32to64(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVWUreg x) @@ -15258,9 +15172,7 @@ func rewriteValueARM64_OpZeroExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpZeroExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpZeroExt8to16(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBUreg x) @@ -15271,9 +15183,7 @@ func rewriteValueARM64_OpZeroExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpZeroExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpZeroExt8to32(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBUreg x) @@ -15284,9 +15194,7 @@ func rewriteValueARM64_OpZeroExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueARM64_OpZeroExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpZeroExt8to64(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBUreg x) @@ -15297,7 +15205,11 @@ func rewriteValueARM64_OpZeroExt8to64(v *Value, config *Config) bool { return true } } -func rewriteBlockARM64(b *Block, config *Config) bool { +func rewriteBlockARM64(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { case BlockARM64EQ: // match: (EQ (CMPconst [0] x) yes no) diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS.go b/src/cmd/compile/internal/ssa/rewriteMIPS.go index 88789d93ee..af3496a91c 100644 --- a/src/cmd/compile/internal/ssa/rewriteMIPS.go +++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go @@ -6,504 +6,502 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValueMIPS(v *Value, config *Config) bool { +func rewriteValueMIPS(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValueMIPS_OpAdd16(v, config) + return rewriteValueMIPS_OpAdd16(v) case OpAdd32: - return rewriteValueMIPS_OpAdd32(v, config) + return rewriteValueMIPS_OpAdd32(v) case OpAdd32F: - return rewriteValueMIPS_OpAdd32F(v, config) + return rewriteValueMIPS_OpAdd32F(v) case OpAdd32withcarry: - return rewriteValueMIPS_OpAdd32withcarry(v, config) + return rewriteValueMIPS_OpAdd32withcarry(v) case OpAdd64F: - return rewriteValueMIPS_OpAdd64F(v, config) + return rewriteValueMIPS_OpAdd64F(v) case OpAdd8: - return rewriteValueMIPS_OpAdd8(v, config) + return rewriteValueMIPS_OpAdd8(v) case OpAddPtr: - return rewriteValueMIPS_OpAddPtr(v, config) + return rewriteValueMIPS_OpAddPtr(v) case OpAddr: - return rewriteValueMIPS_OpAddr(v, config) + return rewriteValueMIPS_OpAddr(v) case OpAnd16: - return rewriteValueMIPS_OpAnd16(v, config) + return rewriteValueMIPS_OpAnd16(v) case OpAnd32: - return rewriteValueMIPS_OpAnd32(v, config) + return rewriteValueMIPS_OpAnd32(v) case OpAnd8: - return rewriteValueMIPS_OpAnd8(v, config) + return rewriteValueMIPS_OpAnd8(v) case OpAndB: - return rewriteValueMIPS_OpAndB(v, config) + return rewriteValueMIPS_OpAndB(v) case OpAtomicAdd32: - return rewriteValueMIPS_OpAtomicAdd32(v, config) + return rewriteValueMIPS_OpAtomicAdd32(v) case OpAtomicAnd8: - return rewriteValueMIPS_OpAtomicAnd8(v, config) + return rewriteValueMIPS_OpAtomicAnd8(v) case OpAtomicCompareAndSwap32: - return rewriteValueMIPS_OpAtomicCompareAndSwap32(v, config) + return rewriteValueMIPS_OpAtomicCompareAndSwap32(v) case OpAtomicExchange32: - return rewriteValueMIPS_OpAtomicExchange32(v, config) + return rewriteValueMIPS_OpAtomicExchange32(v) case OpAtomicLoad32: - return rewriteValueMIPS_OpAtomicLoad32(v, config) + return rewriteValueMIPS_OpAtomicLoad32(v) case OpAtomicLoadPtr: - return rewriteValueMIPS_OpAtomicLoadPtr(v, config) + return rewriteValueMIPS_OpAtomicLoadPtr(v) case OpAtomicOr8: - return rewriteValueMIPS_OpAtomicOr8(v, config) + return rewriteValueMIPS_OpAtomicOr8(v) case OpAtomicStore32: - return rewriteValueMIPS_OpAtomicStore32(v, config) + return rewriteValueMIPS_OpAtomicStore32(v) case OpAtomicStorePtrNoWB: - return rewriteValueMIPS_OpAtomicStorePtrNoWB(v, config) + return rewriteValueMIPS_OpAtomicStorePtrNoWB(v) case OpAvg32u: - return rewriteValueMIPS_OpAvg32u(v, config) + return rewriteValueMIPS_OpAvg32u(v) case OpBitLen32: - return rewriteValueMIPS_OpBitLen32(v, config) + return rewriteValueMIPS_OpBitLen32(v) case OpClosureCall: - return rewriteValueMIPS_OpClosureCall(v, config) + return rewriteValueMIPS_OpClosureCall(v) case OpCom16: - return rewriteValueMIPS_OpCom16(v, config) + return rewriteValueMIPS_OpCom16(v) case OpCom32: - return rewriteValueMIPS_OpCom32(v, config) + return rewriteValueMIPS_OpCom32(v) case OpCom8: - return rewriteValueMIPS_OpCom8(v, config) + return rewriteValueMIPS_OpCom8(v) case OpConst16: - return rewriteValueMIPS_OpConst16(v, config) + return rewriteValueMIPS_OpConst16(v) case OpConst32: - return rewriteValueMIPS_OpConst32(v, config) + return rewriteValueMIPS_OpConst32(v) case OpConst32F: - return rewriteValueMIPS_OpConst32F(v, config) + return rewriteValueMIPS_OpConst32F(v) case OpConst64F: - return rewriteValueMIPS_OpConst64F(v, config) + return rewriteValueMIPS_OpConst64F(v) case OpConst8: - return rewriteValueMIPS_OpConst8(v, config) + return rewriteValueMIPS_OpConst8(v) case OpConstBool: - return rewriteValueMIPS_OpConstBool(v, config) + return rewriteValueMIPS_OpConstBool(v) case OpConstNil: - return rewriteValueMIPS_OpConstNil(v, config) + return rewriteValueMIPS_OpConstNil(v) case OpConvert: - return rewriteValueMIPS_OpConvert(v, config) + return rewriteValueMIPS_OpConvert(v) case OpCtz32: - return rewriteValueMIPS_OpCtz32(v, config) + return rewriteValueMIPS_OpCtz32(v) case OpCvt32Fto32: - return rewriteValueMIPS_OpCvt32Fto32(v, config) + return rewriteValueMIPS_OpCvt32Fto32(v) case OpCvt32Fto64F: - return rewriteValueMIPS_OpCvt32Fto64F(v, config) + return rewriteValueMIPS_OpCvt32Fto64F(v) case OpCvt32to32F: - return rewriteValueMIPS_OpCvt32to32F(v, config) + return rewriteValueMIPS_OpCvt32to32F(v) case OpCvt32to64F: - return rewriteValueMIPS_OpCvt32to64F(v, config) + return rewriteValueMIPS_OpCvt32to64F(v) case OpCvt64Fto32: - return rewriteValueMIPS_OpCvt64Fto32(v, config) + return rewriteValueMIPS_OpCvt64Fto32(v) case OpCvt64Fto32F: - return rewriteValueMIPS_OpCvt64Fto32F(v, config) + return rewriteValueMIPS_OpCvt64Fto32F(v) case OpDiv16: - return rewriteValueMIPS_OpDiv16(v, config) + return rewriteValueMIPS_OpDiv16(v) case OpDiv16u: - return rewriteValueMIPS_OpDiv16u(v, config) + return rewriteValueMIPS_OpDiv16u(v) case OpDiv32: - return rewriteValueMIPS_OpDiv32(v, config) + return rewriteValueMIPS_OpDiv32(v) case OpDiv32F: - return rewriteValueMIPS_OpDiv32F(v, config) + return rewriteValueMIPS_OpDiv32F(v) case OpDiv32u: - return rewriteValueMIPS_OpDiv32u(v, config) + return rewriteValueMIPS_OpDiv32u(v) case OpDiv64F: - return rewriteValueMIPS_OpDiv64F(v, config) + return rewriteValueMIPS_OpDiv64F(v) case OpDiv8: - return rewriteValueMIPS_OpDiv8(v, config) + return rewriteValueMIPS_OpDiv8(v) case OpDiv8u: - return rewriteValueMIPS_OpDiv8u(v, config) + return rewriteValueMIPS_OpDiv8u(v) case OpEq16: - return rewriteValueMIPS_OpEq16(v, config) + return rewriteValueMIPS_OpEq16(v) case OpEq32: - return rewriteValueMIPS_OpEq32(v, config) + return rewriteValueMIPS_OpEq32(v) case OpEq32F: - return rewriteValueMIPS_OpEq32F(v, config) + return rewriteValueMIPS_OpEq32F(v) case OpEq64F: - return rewriteValueMIPS_OpEq64F(v, config) + return rewriteValueMIPS_OpEq64F(v) case OpEq8: - return rewriteValueMIPS_OpEq8(v, config) + return rewriteValueMIPS_OpEq8(v) case OpEqB: - return rewriteValueMIPS_OpEqB(v, config) + return rewriteValueMIPS_OpEqB(v) case OpEqPtr: - return rewriteValueMIPS_OpEqPtr(v, config) + return rewriteValueMIPS_OpEqPtr(v) case OpGeq16: - return rewriteValueMIPS_OpGeq16(v, config) + return rewriteValueMIPS_OpGeq16(v) case OpGeq16U: - return rewriteValueMIPS_OpGeq16U(v, config) + return rewriteValueMIPS_OpGeq16U(v) case OpGeq32: - return rewriteValueMIPS_OpGeq32(v, config) + return rewriteValueMIPS_OpGeq32(v) case OpGeq32F: - return rewriteValueMIPS_OpGeq32F(v, config) + return rewriteValueMIPS_OpGeq32F(v) case OpGeq32U: - return rewriteValueMIPS_OpGeq32U(v, config) + return rewriteValueMIPS_OpGeq32U(v) case OpGeq64F: - return rewriteValueMIPS_OpGeq64F(v, config) + return rewriteValueMIPS_OpGeq64F(v) case OpGeq8: - return rewriteValueMIPS_OpGeq8(v, config) + return rewriteValueMIPS_OpGeq8(v) case OpGeq8U: - return rewriteValueMIPS_OpGeq8U(v, config) + return rewriteValueMIPS_OpGeq8U(v) case OpGetClosurePtr: - return rewriteValueMIPS_OpGetClosurePtr(v, config) + return rewriteValueMIPS_OpGetClosurePtr(v) case OpGreater16: - return rewriteValueMIPS_OpGreater16(v, config) + return rewriteValueMIPS_OpGreater16(v) case OpGreater16U: - return rewriteValueMIPS_OpGreater16U(v, config) + return rewriteValueMIPS_OpGreater16U(v) case OpGreater32: - return rewriteValueMIPS_OpGreater32(v, config) + return rewriteValueMIPS_OpGreater32(v) case OpGreater32F: - return rewriteValueMIPS_OpGreater32F(v, config) + return rewriteValueMIPS_OpGreater32F(v) case OpGreater32U: - return rewriteValueMIPS_OpGreater32U(v, config) + return rewriteValueMIPS_OpGreater32U(v) case OpGreater64F: - return rewriteValueMIPS_OpGreater64F(v, config) + return rewriteValueMIPS_OpGreater64F(v) case OpGreater8: - return rewriteValueMIPS_OpGreater8(v, config) + return rewriteValueMIPS_OpGreater8(v) case OpGreater8U: - return rewriteValueMIPS_OpGreater8U(v, config) + return rewriteValueMIPS_OpGreater8U(v) case OpHmul32: - return rewriteValueMIPS_OpHmul32(v, config) + return rewriteValueMIPS_OpHmul32(v) case OpHmul32u: - return rewriteValueMIPS_OpHmul32u(v, config) + return rewriteValueMIPS_OpHmul32u(v) case OpInterCall: - return rewriteValueMIPS_OpInterCall(v, config) + return rewriteValueMIPS_OpInterCall(v) case OpIsInBounds: - return rewriteValueMIPS_OpIsInBounds(v, config) + return rewriteValueMIPS_OpIsInBounds(v) case OpIsNonNil: - return rewriteValueMIPS_OpIsNonNil(v, config) + return rewriteValueMIPS_OpIsNonNil(v) case OpIsSliceInBounds: - return rewriteValueMIPS_OpIsSliceInBounds(v, config) + return rewriteValueMIPS_OpIsSliceInBounds(v) case OpLeq16: - return rewriteValueMIPS_OpLeq16(v, config) + return rewriteValueMIPS_OpLeq16(v) case OpLeq16U: - return rewriteValueMIPS_OpLeq16U(v, config) + return rewriteValueMIPS_OpLeq16U(v) case OpLeq32: - return rewriteValueMIPS_OpLeq32(v, config) + return rewriteValueMIPS_OpLeq32(v) case OpLeq32F: - return rewriteValueMIPS_OpLeq32F(v, config) + return rewriteValueMIPS_OpLeq32F(v) case OpLeq32U: - return rewriteValueMIPS_OpLeq32U(v, config) + return rewriteValueMIPS_OpLeq32U(v) case OpLeq64F: - return rewriteValueMIPS_OpLeq64F(v, config) + return rewriteValueMIPS_OpLeq64F(v) case OpLeq8: - return rewriteValueMIPS_OpLeq8(v, config) + return rewriteValueMIPS_OpLeq8(v) case OpLeq8U: - return rewriteValueMIPS_OpLeq8U(v, config) + return rewriteValueMIPS_OpLeq8U(v) case OpLess16: - return rewriteValueMIPS_OpLess16(v, config) + return rewriteValueMIPS_OpLess16(v) case OpLess16U: - return rewriteValueMIPS_OpLess16U(v, config) + return rewriteValueMIPS_OpLess16U(v) case OpLess32: - return rewriteValueMIPS_OpLess32(v, config) + return rewriteValueMIPS_OpLess32(v) case OpLess32F: - return rewriteValueMIPS_OpLess32F(v, config) + return rewriteValueMIPS_OpLess32F(v) case OpLess32U: - return rewriteValueMIPS_OpLess32U(v, config) + return rewriteValueMIPS_OpLess32U(v) case OpLess64F: - return rewriteValueMIPS_OpLess64F(v, config) + return rewriteValueMIPS_OpLess64F(v) case OpLess8: - return rewriteValueMIPS_OpLess8(v, config) + return rewriteValueMIPS_OpLess8(v) case OpLess8U: - return rewriteValueMIPS_OpLess8U(v, config) + return rewriteValueMIPS_OpLess8U(v) case OpLoad: - return rewriteValueMIPS_OpLoad(v, config) + return rewriteValueMIPS_OpLoad(v) case OpLsh16x16: - return rewriteValueMIPS_OpLsh16x16(v, config) + return rewriteValueMIPS_OpLsh16x16(v) case OpLsh16x32: - return rewriteValueMIPS_OpLsh16x32(v, config) + return rewriteValueMIPS_OpLsh16x32(v) case OpLsh16x64: - return rewriteValueMIPS_OpLsh16x64(v, config) + return rewriteValueMIPS_OpLsh16x64(v) case OpLsh16x8: - return rewriteValueMIPS_OpLsh16x8(v, config) + return rewriteValueMIPS_OpLsh16x8(v) case OpLsh32x16: - return rewriteValueMIPS_OpLsh32x16(v, config) + return rewriteValueMIPS_OpLsh32x16(v) case OpLsh32x32: - return rewriteValueMIPS_OpLsh32x32(v, config) + return rewriteValueMIPS_OpLsh32x32(v) case OpLsh32x64: - return rewriteValueMIPS_OpLsh32x64(v, config) + return rewriteValueMIPS_OpLsh32x64(v) case OpLsh32x8: - return rewriteValueMIPS_OpLsh32x8(v, config) + return rewriteValueMIPS_OpLsh32x8(v) case OpLsh8x16: - return rewriteValueMIPS_OpLsh8x16(v, config) + return rewriteValueMIPS_OpLsh8x16(v) case OpLsh8x32: - return rewriteValueMIPS_OpLsh8x32(v, config) + return rewriteValueMIPS_OpLsh8x32(v) case OpLsh8x64: - return rewriteValueMIPS_OpLsh8x64(v, config) + return rewriteValueMIPS_OpLsh8x64(v) case OpLsh8x8: - return rewriteValueMIPS_OpLsh8x8(v, config) + return rewriteValueMIPS_OpLsh8x8(v) case OpMIPSADD: - return rewriteValueMIPS_OpMIPSADD(v, config) + return rewriteValueMIPS_OpMIPSADD(v) case OpMIPSADDconst: - return rewriteValueMIPS_OpMIPSADDconst(v, config) + return rewriteValueMIPS_OpMIPSADDconst(v) case OpMIPSAND: - return rewriteValueMIPS_OpMIPSAND(v, config) + return rewriteValueMIPS_OpMIPSAND(v) case OpMIPSANDconst: - return rewriteValueMIPS_OpMIPSANDconst(v, config) + return rewriteValueMIPS_OpMIPSANDconst(v) case OpMIPSCMOVZ: - return rewriteValueMIPS_OpMIPSCMOVZ(v, config) + return rewriteValueMIPS_OpMIPSCMOVZ(v) case OpMIPSCMOVZzero: - return rewriteValueMIPS_OpMIPSCMOVZzero(v, config) + return rewriteValueMIPS_OpMIPSCMOVZzero(v) case OpMIPSLoweredAtomicAdd: - return rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v, config) + return rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v) case OpMIPSLoweredAtomicStore: - return rewriteValueMIPS_OpMIPSLoweredAtomicStore(v, config) + return rewriteValueMIPS_OpMIPSLoweredAtomicStore(v) case OpMIPSMOVBUload: - return rewriteValueMIPS_OpMIPSMOVBUload(v, config) + return rewriteValueMIPS_OpMIPSMOVBUload(v) case OpMIPSMOVBUreg: - return rewriteValueMIPS_OpMIPSMOVBUreg(v, config) + return rewriteValueMIPS_OpMIPSMOVBUreg(v) case OpMIPSMOVBload: - return rewriteValueMIPS_OpMIPSMOVBload(v, config) + return rewriteValueMIPS_OpMIPSMOVBload(v) case OpMIPSMOVBreg: - return rewriteValueMIPS_OpMIPSMOVBreg(v, config) + return rewriteValueMIPS_OpMIPSMOVBreg(v) case OpMIPSMOVBstore: - return rewriteValueMIPS_OpMIPSMOVBstore(v, config) + return rewriteValueMIPS_OpMIPSMOVBstore(v) case OpMIPSMOVBstorezero: - return rewriteValueMIPS_OpMIPSMOVBstorezero(v, config) + return rewriteValueMIPS_OpMIPSMOVBstorezero(v) case OpMIPSMOVDload: - return rewriteValueMIPS_OpMIPSMOVDload(v, config) + return rewriteValueMIPS_OpMIPSMOVDload(v) case OpMIPSMOVDstore: - return rewriteValueMIPS_OpMIPSMOVDstore(v, config) + return rewriteValueMIPS_OpMIPSMOVDstore(v) case OpMIPSMOVFload: - return rewriteValueMIPS_OpMIPSMOVFload(v, config) + return rewriteValueMIPS_OpMIPSMOVFload(v) case OpMIPSMOVFstore: - return rewriteValueMIPS_OpMIPSMOVFstore(v, config) + return rewriteValueMIPS_OpMIPSMOVFstore(v) case OpMIPSMOVHUload: - return rewriteValueMIPS_OpMIPSMOVHUload(v, config) + return rewriteValueMIPS_OpMIPSMOVHUload(v) case OpMIPSMOVHUreg: - return rewriteValueMIPS_OpMIPSMOVHUreg(v, config) + return rewriteValueMIPS_OpMIPSMOVHUreg(v) case OpMIPSMOVHload: - return rewriteValueMIPS_OpMIPSMOVHload(v, config) + return rewriteValueMIPS_OpMIPSMOVHload(v) case OpMIPSMOVHreg: - return rewriteValueMIPS_OpMIPSMOVHreg(v, config) + return rewriteValueMIPS_OpMIPSMOVHreg(v) case OpMIPSMOVHstore: - return rewriteValueMIPS_OpMIPSMOVHstore(v, config) + return rewriteValueMIPS_OpMIPSMOVHstore(v) case OpMIPSMOVHstorezero: - return rewriteValueMIPS_OpMIPSMOVHstorezero(v, config) + return rewriteValueMIPS_OpMIPSMOVHstorezero(v) case OpMIPSMOVWload: - return rewriteValueMIPS_OpMIPSMOVWload(v, config) + return rewriteValueMIPS_OpMIPSMOVWload(v) case OpMIPSMOVWreg: - return rewriteValueMIPS_OpMIPSMOVWreg(v, config) + return rewriteValueMIPS_OpMIPSMOVWreg(v) case OpMIPSMOVWstore: - return rewriteValueMIPS_OpMIPSMOVWstore(v, config) + return rewriteValueMIPS_OpMIPSMOVWstore(v) case OpMIPSMOVWstorezero: - return rewriteValueMIPS_OpMIPSMOVWstorezero(v, config) + return rewriteValueMIPS_OpMIPSMOVWstorezero(v) case OpMIPSMUL: - return rewriteValueMIPS_OpMIPSMUL(v, config) + return rewriteValueMIPS_OpMIPSMUL(v) case OpMIPSNEG: - return rewriteValueMIPS_OpMIPSNEG(v, config) + return rewriteValueMIPS_OpMIPSNEG(v) case OpMIPSNOR: - return rewriteValueMIPS_OpMIPSNOR(v, config) + return rewriteValueMIPS_OpMIPSNOR(v) case OpMIPSNORconst: - return rewriteValueMIPS_OpMIPSNORconst(v, config) + return rewriteValueMIPS_OpMIPSNORconst(v) case OpMIPSOR: - return rewriteValueMIPS_OpMIPSOR(v, config) + return rewriteValueMIPS_OpMIPSOR(v) case OpMIPSORconst: - return rewriteValueMIPS_OpMIPSORconst(v, config) + return rewriteValueMIPS_OpMIPSORconst(v) case OpMIPSSGT: - return rewriteValueMIPS_OpMIPSSGT(v, config) + return rewriteValueMIPS_OpMIPSSGT(v) case OpMIPSSGTU: - return rewriteValueMIPS_OpMIPSSGTU(v, config) + return rewriteValueMIPS_OpMIPSSGTU(v) case OpMIPSSGTUconst: - return rewriteValueMIPS_OpMIPSSGTUconst(v, config) + return rewriteValueMIPS_OpMIPSSGTUconst(v) case OpMIPSSGTUzero: - return rewriteValueMIPS_OpMIPSSGTUzero(v, config) + return rewriteValueMIPS_OpMIPSSGTUzero(v) case OpMIPSSGTconst: - return rewriteValueMIPS_OpMIPSSGTconst(v, config) + return rewriteValueMIPS_OpMIPSSGTconst(v) case OpMIPSSGTzero: - return rewriteValueMIPS_OpMIPSSGTzero(v, config) + return rewriteValueMIPS_OpMIPSSGTzero(v) case OpMIPSSLL: - return rewriteValueMIPS_OpMIPSSLL(v, config) + return rewriteValueMIPS_OpMIPSSLL(v) case OpMIPSSLLconst: - return rewriteValueMIPS_OpMIPSSLLconst(v, config) + return rewriteValueMIPS_OpMIPSSLLconst(v) case OpMIPSSRA: - return rewriteValueMIPS_OpMIPSSRA(v, config) + return rewriteValueMIPS_OpMIPSSRA(v) case OpMIPSSRAconst: - return rewriteValueMIPS_OpMIPSSRAconst(v, config) + return rewriteValueMIPS_OpMIPSSRAconst(v) case OpMIPSSRL: - return rewriteValueMIPS_OpMIPSSRL(v, config) + return rewriteValueMIPS_OpMIPSSRL(v) case OpMIPSSRLconst: - return rewriteValueMIPS_OpMIPSSRLconst(v, config) + return rewriteValueMIPS_OpMIPSSRLconst(v) case OpMIPSSUB: - return rewriteValueMIPS_OpMIPSSUB(v, config) + return rewriteValueMIPS_OpMIPSSUB(v) case OpMIPSSUBconst: - return rewriteValueMIPS_OpMIPSSUBconst(v, config) + return rewriteValueMIPS_OpMIPSSUBconst(v) case OpMIPSXOR: - return rewriteValueMIPS_OpMIPSXOR(v, config) + return rewriteValueMIPS_OpMIPSXOR(v) case OpMIPSXORconst: - return rewriteValueMIPS_OpMIPSXORconst(v, config) + return rewriteValueMIPS_OpMIPSXORconst(v) case OpMod16: - return rewriteValueMIPS_OpMod16(v, config) + return rewriteValueMIPS_OpMod16(v) case OpMod16u: - return rewriteValueMIPS_OpMod16u(v, config) + return rewriteValueMIPS_OpMod16u(v) case OpMod32: - return rewriteValueMIPS_OpMod32(v, config) + return rewriteValueMIPS_OpMod32(v) case OpMod32u: - return rewriteValueMIPS_OpMod32u(v, config) + return rewriteValueMIPS_OpMod32u(v) case OpMod8: - return rewriteValueMIPS_OpMod8(v, config) + return rewriteValueMIPS_OpMod8(v) case OpMod8u: - return rewriteValueMIPS_OpMod8u(v, config) + return rewriteValueMIPS_OpMod8u(v) case OpMove: - return rewriteValueMIPS_OpMove(v, config) + return rewriteValueMIPS_OpMove(v) case OpMul16: - return rewriteValueMIPS_OpMul16(v, config) + return rewriteValueMIPS_OpMul16(v) case OpMul32: - return rewriteValueMIPS_OpMul32(v, config) + return rewriteValueMIPS_OpMul32(v) case OpMul32F: - return rewriteValueMIPS_OpMul32F(v, config) + return rewriteValueMIPS_OpMul32F(v) case OpMul32uhilo: - return rewriteValueMIPS_OpMul32uhilo(v, config) + return rewriteValueMIPS_OpMul32uhilo(v) case OpMul64F: - return rewriteValueMIPS_OpMul64F(v, config) + return rewriteValueMIPS_OpMul64F(v) case OpMul8: - return rewriteValueMIPS_OpMul8(v, config) + return rewriteValueMIPS_OpMul8(v) case OpNeg16: - return rewriteValueMIPS_OpNeg16(v, config) + return rewriteValueMIPS_OpNeg16(v) case OpNeg32: - return rewriteValueMIPS_OpNeg32(v, config) + return rewriteValueMIPS_OpNeg32(v) case OpNeg32F: - return rewriteValueMIPS_OpNeg32F(v, config) + return rewriteValueMIPS_OpNeg32F(v) case OpNeg64F: - return rewriteValueMIPS_OpNeg64F(v, config) + return rewriteValueMIPS_OpNeg64F(v) case OpNeg8: - return rewriteValueMIPS_OpNeg8(v, config) + return rewriteValueMIPS_OpNeg8(v) case OpNeq16: - return rewriteValueMIPS_OpNeq16(v, config) + return rewriteValueMIPS_OpNeq16(v) case OpNeq32: - return rewriteValueMIPS_OpNeq32(v, config) + return rewriteValueMIPS_OpNeq32(v) case OpNeq32F: - return rewriteValueMIPS_OpNeq32F(v, config) + return rewriteValueMIPS_OpNeq32F(v) case OpNeq64F: - return rewriteValueMIPS_OpNeq64F(v, config) + return rewriteValueMIPS_OpNeq64F(v) case OpNeq8: - return rewriteValueMIPS_OpNeq8(v, config) + return rewriteValueMIPS_OpNeq8(v) case OpNeqB: - return rewriteValueMIPS_OpNeqB(v, config) + return rewriteValueMIPS_OpNeqB(v) case OpNeqPtr: - return rewriteValueMIPS_OpNeqPtr(v, config) + return rewriteValueMIPS_OpNeqPtr(v) case OpNilCheck: - return rewriteValueMIPS_OpNilCheck(v, config) + return rewriteValueMIPS_OpNilCheck(v) case OpNot: - return rewriteValueMIPS_OpNot(v, config) + return rewriteValueMIPS_OpNot(v) case OpOffPtr: - return rewriteValueMIPS_OpOffPtr(v, config) + return rewriteValueMIPS_OpOffPtr(v) case OpOr16: - return rewriteValueMIPS_OpOr16(v, config) + return rewriteValueMIPS_OpOr16(v) case OpOr32: - return rewriteValueMIPS_OpOr32(v, config) + return rewriteValueMIPS_OpOr32(v) case OpOr8: - return rewriteValueMIPS_OpOr8(v, config) + return rewriteValueMIPS_OpOr8(v) case OpOrB: - return rewriteValueMIPS_OpOrB(v, config) + return rewriteValueMIPS_OpOrB(v) case OpRound32F: - return rewriteValueMIPS_OpRound32F(v, config) + return rewriteValueMIPS_OpRound32F(v) case OpRound64F: - return rewriteValueMIPS_OpRound64F(v, config) + return rewriteValueMIPS_OpRound64F(v) case OpRsh16Ux16: - return rewriteValueMIPS_OpRsh16Ux16(v, config) + return rewriteValueMIPS_OpRsh16Ux16(v) case OpRsh16Ux32: - return rewriteValueMIPS_OpRsh16Ux32(v, config) + return rewriteValueMIPS_OpRsh16Ux32(v) case OpRsh16Ux64: - return rewriteValueMIPS_OpRsh16Ux64(v, config) + return rewriteValueMIPS_OpRsh16Ux64(v) case OpRsh16Ux8: - return rewriteValueMIPS_OpRsh16Ux8(v, config) + return rewriteValueMIPS_OpRsh16Ux8(v) case OpRsh16x16: - return rewriteValueMIPS_OpRsh16x16(v, config) + return rewriteValueMIPS_OpRsh16x16(v) case OpRsh16x32: - return rewriteValueMIPS_OpRsh16x32(v, config) + return rewriteValueMIPS_OpRsh16x32(v) case OpRsh16x64: - return rewriteValueMIPS_OpRsh16x64(v, config) + return rewriteValueMIPS_OpRsh16x64(v) case OpRsh16x8: - return rewriteValueMIPS_OpRsh16x8(v, config) + return rewriteValueMIPS_OpRsh16x8(v) case OpRsh32Ux16: - return rewriteValueMIPS_OpRsh32Ux16(v, config) + return rewriteValueMIPS_OpRsh32Ux16(v) case OpRsh32Ux32: - return rewriteValueMIPS_OpRsh32Ux32(v, config) + return rewriteValueMIPS_OpRsh32Ux32(v) case OpRsh32Ux64: - return rewriteValueMIPS_OpRsh32Ux64(v, config) + return rewriteValueMIPS_OpRsh32Ux64(v) case OpRsh32Ux8: - return rewriteValueMIPS_OpRsh32Ux8(v, config) + return rewriteValueMIPS_OpRsh32Ux8(v) case OpRsh32x16: - return rewriteValueMIPS_OpRsh32x16(v, config) + return rewriteValueMIPS_OpRsh32x16(v) case OpRsh32x32: - return rewriteValueMIPS_OpRsh32x32(v, config) + return rewriteValueMIPS_OpRsh32x32(v) case OpRsh32x64: - return rewriteValueMIPS_OpRsh32x64(v, config) + return rewriteValueMIPS_OpRsh32x64(v) case OpRsh32x8: - return rewriteValueMIPS_OpRsh32x8(v, config) + return rewriteValueMIPS_OpRsh32x8(v) case OpRsh8Ux16: - return rewriteValueMIPS_OpRsh8Ux16(v, config) + return rewriteValueMIPS_OpRsh8Ux16(v) case OpRsh8Ux32: - return rewriteValueMIPS_OpRsh8Ux32(v, config) + return rewriteValueMIPS_OpRsh8Ux32(v) case OpRsh8Ux64: - return rewriteValueMIPS_OpRsh8Ux64(v, config) + return rewriteValueMIPS_OpRsh8Ux64(v) case OpRsh8Ux8: - return rewriteValueMIPS_OpRsh8Ux8(v, config) + return rewriteValueMIPS_OpRsh8Ux8(v) case OpRsh8x16: - return rewriteValueMIPS_OpRsh8x16(v, config) + return rewriteValueMIPS_OpRsh8x16(v) case OpRsh8x32: - return rewriteValueMIPS_OpRsh8x32(v, config) + return rewriteValueMIPS_OpRsh8x32(v) case OpRsh8x64: - return rewriteValueMIPS_OpRsh8x64(v, config) + return rewriteValueMIPS_OpRsh8x64(v) case OpRsh8x8: - return rewriteValueMIPS_OpRsh8x8(v, config) + return rewriteValueMIPS_OpRsh8x8(v) case OpSelect0: - return rewriteValueMIPS_OpSelect0(v, config) + return rewriteValueMIPS_OpSelect0(v) case OpSelect1: - return rewriteValueMIPS_OpSelect1(v, config) + return rewriteValueMIPS_OpSelect1(v) case OpSignExt16to32: - return rewriteValueMIPS_OpSignExt16to32(v, config) + return rewriteValueMIPS_OpSignExt16to32(v) case OpSignExt8to16: - return rewriteValueMIPS_OpSignExt8to16(v, config) + return rewriteValueMIPS_OpSignExt8to16(v) case OpSignExt8to32: - return rewriteValueMIPS_OpSignExt8to32(v, config) + return rewriteValueMIPS_OpSignExt8to32(v) case OpSignmask: - return rewriteValueMIPS_OpSignmask(v, config) + return rewriteValueMIPS_OpSignmask(v) case OpSlicemask: - return rewriteValueMIPS_OpSlicemask(v, config) + return rewriteValueMIPS_OpSlicemask(v) case OpSqrt: - return rewriteValueMIPS_OpSqrt(v, config) + return rewriteValueMIPS_OpSqrt(v) case OpStaticCall: - return rewriteValueMIPS_OpStaticCall(v, config) + return rewriteValueMIPS_OpStaticCall(v) case OpStore: - return rewriteValueMIPS_OpStore(v, config) + return rewriteValueMIPS_OpStore(v) case OpSub16: - return rewriteValueMIPS_OpSub16(v, config) + return rewriteValueMIPS_OpSub16(v) case OpSub32: - return rewriteValueMIPS_OpSub32(v, config) + return rewriteValueMIPS_OpSub32(v) case OpSub32F: - return rewriteValueMIPS_OpSub32F(v, config) + return rewriteValueMIPS_OpSub32F(v) case OpSub32withcarry: - return rewriteValueMIPS_OpSub32withcarry(v, config) + return rewriteValueMIPS_OpSub32withcarry(v) case OpSub64F: - return rewriteValueMIPS_OpSub64F(v, config) + return rewriteValueMIPS_OpSub64F(v) case OpSub8: - return rewriteValueMIPS_OpSub8(v, config) + return rewriteValueMIPS_OpSub8(v) case OpSubPtr: - return rewriteValueMIPS_OpSubPtr(v, config) + return rewriteValueMIPS_OpSubPtr(v) case OpTrunc16to8: - return rewriteValueMIPS_OpTrunc16to8(v, config) + return rewriteValueMIPS_OpTrunc16to8(v) case OpTrunc32to16: - return rewriteValueMIPS_OpTrunc32to16(v, config) + return rewriteValueMIPS_OpTrunc32to16(v) case OpTrunc32to8: - return rewriteValueMIPS_OpTrunc32to8(v, config) + return rewriteValueMIPS_OpTrunc32to8(v) case OpXor16: - return rewriteValueMIPS_OpXor16(v, config) + return rewriteValueMIPS_OpXor16(v) case OpXor32: - return rewriteValueMIPS_OpXor32(v, config) + return rewriteValueMIPS_OpXor32(v) case OpXor8: - return rewriteValueMIPS_OpXor8(v, config) + return rewriteValueMIPS_OpXor8(v) case OpZero: - return rewriteValueMIPS_OpZero(v, config) + return rewriteValueMIPS_OpZero(v) case OpZeroExt16to32: - return rewriteValueMIPS_OpZeroExt16to32(v, config) + return rewriteValueMIPS_OpZeroExt16to32(v) case OpZeroExt8to16: - return rewriteValueMIPS_OpZeroExt8to16(v, config) + return rewriteValueMIPS_OpZeroExt8to16(v) case OpZeroExt8to32: - return rewriteValueMIPS_OpZeroExt8to32(v, config) + return rewriteValueMIPS_OpZeroExt8to32(v) case OpZeromask: - return rewriteValueMIPS_OpZeromask(v, config) + return rewriteValueMIPS_OpZeromask(v) } return false } -func rewriteValueMIPS_OpAdd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAdd16(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADD x y) @@ -516,9 +514,7 @@ func rewriteValueMIPS_OpAdd16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAdd32(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADD x y) @@ -531,9 +527,7 @@ func rewriteValueMIPS_OpAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAdd32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAdd32F(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDF x y) @@ -546,7 +540,7 @@ func rewriteValueMIPS_OpAdd32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAdd32withcarry(v *Value, config *Config) bool { +func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool { b := v.Block _ = b // match: (Add32withcarry <t> x y c) @@ -566,9 +560,7 @@ func rewriteValueMIPS_OpAdd32withcarry(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAdd64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAdd64F(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDD x y) @@ -581,9 +573,7 @@ func rewriteValueMIPS_OpAdd64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAdd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAdd8(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADD x y) @@ -596,9 +586,7 @@ func rewriteValueMIPS_OpAdd8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAddPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAddPtr(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -611,9 +599,7 @@ func rewriteValueMIPS_OpAddPtr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAddr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAddr(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVWaddr {sym} base) @@ -626,9 +612,7 @@ func rewriteValueMIPS_OpAddr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAnd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAnd16(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -641,9 +625,7 @@ func rewriteValueMIPS_OpAnd16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAnd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAnd32(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -656,9 +638,7 @@ func rewriteValueMIPS_OpAnd32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAnd8(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -671,9 +651,7 @@ func rewriteValueMIPS_OpAnd8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAndB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAndB(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -686,9 +664,7 @@ func rewriteValueMIPS_OpAndB(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAtomicAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool { // match: (AtomicAdd32 ptr val mem) // cond: // result: (LoweredAtomicAdd ptr val mem) @@ -703,12 +679,16 @@ func rewriteValueMIPS_OpAtomicAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAtomicAnd8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (AtomicAnd8 ptr val mem) // cond: !config.BigEndian - // result: (LoweredAtomicAnd (AND <config.fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (OR <config.fe.TypeUInt32()> (SLL <config.fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <config.fe.TypeUInt32()> [3] (ANDconst <config.fe.TypeUInt32()> [3] ptr))) (NORconst [0] <config.fe.TypeUInt32()> (SLL <config.fe.TypeUInt32()> (MOVWconst [0xff]) (SLLconst <config.fe.TypeUInt32()> [3] (ANDconst <config.fe.TypeUInt32()> [3] (XORconst <config.fe.TypeUInt32()> [3] ptr)))))) mem) + // result: (LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] ptr))) (NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] (XORconst <fe.TypeUInt32()> [3] ptr)))))) mem) for { ptr := v.Args[0] val := v.Args[1] @@ -717,36 +697,36 @@ func rewriteValueMIPS_OpAtomicAnd8(v *Value, config *Config) bool { break } v.reset(OpMIPSLoweredAtomicAnd) - v0 := b.NewValue0(v.Pos, OpMIPSAND, config.fe.TypeUInt32().PtrTo()) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSAND, fe.TypeUInt32().PtrTo()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = ^3 v0.AddArg(v1) v0.AddArg(ptr) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSOR, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpMIPSSLL, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSOR, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v4.AddArg(val) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v5.AuxInt = 3 - v6 := b.NewValue0(v.Pos, OpMIPSANDconst, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32()) v6.AuxInt = 3 v6.AddArg(ptr) v5.AddArg(v6) v3.AddArg(v5) v2.AddArg(v3) - v7 := b.NewValue0(v.Pos, OpMIPSNORconst, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpMIPSNORconst, fe.TypeUInt32()) v7.AuxInt = 0 - v8 := b.NewValue0(v.Pos, OpMIPSSLL, config.fe.TypeUInt32()) - v9 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v9.AuxInt = 0xff v8.AddArg(v9) - v10 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v10 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v10.AuxInt = 3 - v11 := b.NewValue0(v.Pos, OpMIPSANDconst, config.fe.TypeUInt32()) + v11 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32()) v11.AuxInt = 3 - v12 := b.NewValue0(v.Pos, OpMIPSXORconst, config.fe.TypeUInt32()) + v12 := b.NewValue0(v.Pos, OpMIPSXORconst, fe.TypeUInt32()) v12.AuxInt = 3 v12.AddArg(ptr) v11.AddArg(v12) @@ -760,7 +740,7 @@ func rewriteValueMIPS_OpAtomicAnd8(v *Value, config *Config) bool { } // match: (AtomicAnd8 ptr val mem) // cond: config.BigEndian - // result: (LoweredAtomicAnd (AND <config.fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (OR <config.fe.TypeUInt32()> (SLL <config.fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <config.fe.TypeUInt32()> [3] (ANDconst <config.fe.TypeUInt32()> [3] (XORconst <config.fe.TypeUInt32()> [3] ptr)))) (NORconst [0] <config.fe.TypeUInt32()> (SLL <config.fe.TypeUInt32()> (MOVWconst [0xff]) (SLLconst <config.fe.TypeUInt32()> [3] (ANDconst <config.fe.TypeUInt32()> [3] (XORconst <config.fe.TypeUInt32()> [3] ptr)))))) mem) + // result: (LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] (XORconst <fe.TypeUInt32()> [3] ptr)))) (NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] (XORconst <fe.TypeUInt32()> [3] ptr)))))) mem) for { ptr := v.Args[0] val := v.Args[1] @@ -769,39 +749,39 @@ func rewriteValueMIPS_OpAtomicAnd8(v *Value, config *Config) bool { break } v.reset(OpMIPSLoweredAtomicAnd) - v0 := b.NewValue0(v.Pos, OpMIPSAND, config.fe.TypeUInt32().PtrTo()) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSAND, fe.TypeUInt32().PtrTo()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = ^3 v0.AddArg(v1) v0.AddArg(ptr) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSOR, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpMIPSSLL, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSOR, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v4.AddArg(val) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v5.AuxInt = 3 - v6 := b.NewValue0(v.Pos, OpMIPSANDconst, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32()) v6.AuxInt = 3 - v7 := b.NewValue0(v.Pos, OpMIPSXORconst, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpMIPSXORconst, fe.TypeUInt32()) v7.AuxInt = 3 v7.AddArg(ptr) v6.AddArg(v7) v5.AddArg(v6) v3.AddArg(v5) v2.AddArg(v3) - v8 := b.NewValue0(v.Pos, OpMIPSNORconst, config.fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpMIPSNORconst, fe.TypeUInt32()) v8.AuxInt = 0 - v9 := b.NewValue0(v.Pos, OpMIPSSLL, config.fe.TypeUInt32()) - v10 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32()) + v10 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v10.AuxInt = 0xff v9.AddArg(v10) - v11 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v11 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v11.AuxInt = 3 - v12 := b.NewValue0(v.Pos, OpMIPSANDconst, config.fe.TypeUInt32()) + v12 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32()) v12.AuxInt = 3 - v13 := b.NewValue0(v.Pos, OpMIPSXORconst, config.fe.TypeUInt32()) + v13 := b.NewValue0(v.Pos, OpMIPSXORconst, fe.TypeUInt32()) v13.AuxInt = 3 v13.AddArg(ptr) v12.AddArg(v13) @@ -815,9 +795,7 @@ func rewriteValueMIPS_OpAtomicAnd8(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (LoweredAtomicCas ptr old new_ mem) @@ -834,9 +812,7 @@ func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAtomicExchange32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (LoweredAtomicExchange ptr val mem) @@ -851,9 +827,7 @@ func rewriteValueMIPS_OpAtomicExchange32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAtomicLoad32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (LoweredAtomicLoad ptr mem) @@ -866,9 +840,7 @@ func rewriteValueMIPS_OpAtomicLoad32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAtomicLoadPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool { // match: (AtomicLoadPtr ptr mem) // cond: // result: (LoweredAtomicLoad ptr mem) @@ -881,12 +853,16 @@ func rewriteValueMIPS_OpAtomicLoadPtr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAtomicOr8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpAtomicOr8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (AtomicOr8 ptr val mem) // cond: !config.BigEndian - // result: (LoweredAtomicOr (AND <config.fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (SLL <config.fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <config.fe.TypeUInt32()> [3] (ANDconst <config.fe.TypeUInt32()> [3] ptr))) mem) + // result: (LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] ptr))) mem) for { ptr := v.Args[0] val := v.Args[1] @@ -895,19 +871,19 @@ func rewriteValueMIPS_OpAtomicOr8(v *Value, config *Config) bool { break } v.reset(OpMIPSLoweredAtomicOr) - v0 := b.NewValue0(v.Pos, OpMIPSAND, config.fe.TypeUInt32().PtrTo()) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSAND, fe.TypeUInt32().PtrTo()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = ^3 v0.AddArg(v1) v0.AddArg(ptr) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSSLL, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v3.AddArg(val) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v4.AuxInt = 3 - v5 := b.NewValue0(v.Pos, OpMIPSANDconst, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32()) v5.AuxInt = 3 v5.AddArg(ptr) v4.AddArg(v5) @@ -918,7 +894,7 @@ func rewriteValueMIPS_OpAtomicOr8(v *Value, config *Config) bool { } // match: (AtomicOr8 ptr val mem) // cond: config.BigEndian - // result: (LoweredAtomicOr (AND <config.fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (SLL <config.fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <config.fe.TypeUInt32()> [3] (ANDconst <config.fe.TypeUInt32()> [3] (XORconst <config.fe.TypeUInt32()> [3] ptr)))) mem) + // result: (LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] (XORconst <fe.TypeUInt32()> [3] ptr)))) mem) for { ptr := v.Args[0] val := v.Args[1] @@ -927,21 +903,21 @@ func rewriteValueMIPS_OpAtomicOr8(v *Value, config *Config) bool { break } v.reset(OpMIPSLoweredAtomicOr) - v0 := b.NewValue0(v.Pos, OpMIPSAND, config.fe.TypeUInt32().PtrTo()) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSAND, fe.TypeUInt32().PtrTo()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = ^3 v0.AddArg(v1) v0.AddArg(ptr) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSSLL, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v3.AddArg(val) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v4.AuxInt = 3 - v5 := b.NewValue0(v.Pos, OpMIPSANDconst, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32()) v5.AuxInt = 3 - v6 := b.NewValue0(v.Pos, OpMIPSXORconst, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpMIPSXORconst, fe.TypeUInt32()) v6.AuxInt = 3 v6.AddArg(ptr) v5.AddArg(v6) @@ -953,9 +929,7 @@ func rewriteValueMIPS_OpAtomicOr8(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpAtomicStore32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAtomicStore32(v *Value) bool { // match: (AtomicStore32 ptr val mem) // cond: // result: (LoweredAtomicStore ptr val mem) @@ -970,9 +944,7 @@ func rewriteValueMIPS_OpAtomicStore32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool { // match: (AtomicStorePtrNoWB ptr val mem) // cond: // result: (LoweredAtomicStore ptr val mem) @@ -987,7 +959,7 @@ func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpAvg32u(v *Value, config *Config) bool { +func rewriteValueMIPS_OpAvg32u(v *Value) bool { b := v.Block _ = b // match: (Avg32u <t> x y) @@ -1009,9 +981,13 @@ func rewriteValueMIPS_OpAvg32u(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpBitLen32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpBitLen32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (BitLen32 <t> x) // cond: // result: (SUB (MOVWconst [32]) (CLZ <t> x)) @@ -1019,7 +995,7 @@ func rewriteValueMIPS_OpBitLen32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] v.reset(OpMIPSSUB) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 32 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSCLZ, t) @@ -1028,9 +1004,7 @@ func rewriteValueMIPS_OpBitLen32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpClosureCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpClosureCall(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -1047,9 +1021,7 @@ func rewriteValueMIPS_OpClosureCall(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCom16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpCom16(v *Value) bool { // match: (Com16 x) // cond: // result: (NORconst [0] x) @@ -1061,9 +1033,7 @@ func rewriteValueMIPS_OpCom16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCom32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpCom32(v *Value) bool { // match: (Com32 x) // cond: // result: (NORconst [0] x) @@ -1075,9 +1045,7 @@ func rewriteValueMIPS_OpCom32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCom8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpCom8(v *Value) bool { // match: (Com8 x) // cond: // result: (NORconst [0] x) @@ -1089,9 +1057,7 @@ func rewriteValueMIPS_OpCom8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpConst16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpConst16(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVWconst [val]) @@ -1102,9 +1068,7 @@ func rewriteValueMIPS_OpConst16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpConst32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpConst32(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVWconst [val]) @@ -1115,9 +1079,7 @@ func rewriteValueMIPS_OpConst32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpConst32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpConst32F(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVFconst [val]) @@ -1128,9 +1090,7 @@ func rewriteValueMIPS_OpConst32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpConst64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpConst64F(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVDconst [val]) @@ -1141,9 +1101,7 @@ func rewriteValueMIPS_OpConst64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpConst8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpConst8(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVWconst [val]) @@ -1154,9 +1112,7 @@ func rewriteValueMIPS_OpConst8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpConstBool(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpConstBool(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVWconst [b]) @@ -1167,9 +1123,7 @@ func rewriteValueMIPS_OpConstBool(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpConstNil(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpConstNil(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVWconst [0]) @@ -1179,9 +1133,7 @@ func rewriteValueMIPS_OpConstNil(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpConvert(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpConvert(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVWconvert x mem) @@ -1194,9 +1146,13 @@ func rewriteValueMIPS_OpConvert(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCtz32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpCtz32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Ctz32 <t> x) // cond: // result: (SUB (MOVWconst [32]) (CLZ <t> (SUBconst <t> [1] (AND <t> x (NEG <t> x))))) @@ -1204,7 +1160,7 @@ func rewriteValueMIPS_OpCtz32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] v.reset(OpMIPSSUB) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 32 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSCLZ, t) @@ -1221,9 +1177,7 @@ func rewriteValueMIPS_OpCtz32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCvt32Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (TRUNCFW x) @@ -1234,9 +1188,7 @@ func rewriteValueMIPS_OpCvt32Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCvt32Fto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (MOVFD x) @@ -1247,9 +1199,7 @@ func rewriteValueMIPS_OpCvt32Fto64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCvt32to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpCvt32to32F(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (MOVWF x) @@ -1260,9 +1210,7 @@ func rewriteValueMIPS_OpCvt32to32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCvt32to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpCvt32to64F(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (MOVWD x) @@ -1273,9 +1221,7 @@ func rewriteValueMIPS_OpCvt32to64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCvt64Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (TRUNCDW x) @@ -1286,9 +1232,7 @@ func rewriteValueMIPS_OpCvt64Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpCvt64Fto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (MOVDF x) @@ -1299,9 +1243,13 @@ func rewriteValueMIPS_OpCvt64Fto32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpDiv16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpDiv16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16 x y) // cond: // result: (Select1 (DIV (SignExt16to32 x) (SignExt16to32 y))) @@ -1309,20 +1257,24 @@ func rewriteValueMIPS_OpDiv16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(config.fe.TypeInt32(), config.fe.TypeInt32())) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpDiv16u(v *Value, config *Config) bool { +func rewriteValueMIPS_OpDiv16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16u x y) // cond: // result: (Select1 (DIVU (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -1330,20 +1282,24 @@ func rewriteValueMIPS_OpDiv16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpDiv32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpDiv32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32 x y) // cond: // result: (Select1 (DIV x y)) @@ -1351,16 +1307,14 @@ func rewriteValueMIPS_OpDiv32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(config.fe.TypeInt32(), config.fe.TypeInt32())) + v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpDiv32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpDiv32F(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVF x y) @@ -1373,9 +1327,13 @@ func rewriteValueMIPS_OpDiv32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpDiv32u(v *Value, config *Config) bool { +func rewriteValueMIPS_OpDiv32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32u x y) // cond: // result: (Select1 (DIVU x y)) @@ -1383,16 +1341,14 @@ func rewriteValueMIPS_OpDiv32u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) + v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpDiv64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpDiv64F(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVD x y) @@ -1405,9 +1361,13 @@ func rewriteValueMIPS_OpDiv64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpDiv8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpDiv8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8 x y) // cond: // result: (Select1 (DIV (SignExt8to32 x) (SignExt8to32 y))) @@ -1415,20 +1375,24 @@ func rewriteValueMIPS_OpDiv8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(config.fe.TypeInt32(), config.fe.TypeInt32())) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpDiv8u(v *Value, config *Config) bool { +func rewriteValueMIPS_OpDiv8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8u x y) // cond: // result: (Select1 (DIVU (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -1436,20 +1400,24 @@ func rewriteValueMIPS_OpDiv8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpEq16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpEq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq16 x y) // cond: // result: (SGTUconst [1] (XOR (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -1458,20 +1426,24 @@ func rewriteValueMIPS_OpEq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSSGTUconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSXOR, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpEq32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpEq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq32 x y) // cond: // result: (SGTUconst [1] (XOR x y)) @@ -1480,14 +1452,14 @@ func rewriteValueMIPS_OpEq32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSSGTUconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSXOR, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpEq32F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpEq32F(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -1504,7 +1476,7 @@ func rewriteValueMIPS_OpEq32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpEq64F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpEq64F(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -1521,9 +1493,13 @@ func rewriteValueMIPS_OpEq64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpEq8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpEq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq8 x y) // cond: // result: (SGTUconst [1] (XOR (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -1532,38 +1508,46 @@ func rewriteValueMIPS_OpEq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSSGTUconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSXOR, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpEqB(v *Value, config *Config) bool { +func rewriteValueMIPS_OpEqB(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqB x y) // cond: - // result: (XORconst [1] (XOR <config.fe.TypeBool()> x y)) + // result: (XORconst [1] (XOR <fe.TypeBool()> x y)) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSXOR, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeBool()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpEqPtr(v *Value, config *Config) bool { +func rewriteValueMIPS_OpEqPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqPtr x y) // cond: // result: (SGTUconst [1] (XOR x y)) @@ -1572,16 +1556,20 @@ func rewriteValueMIPS_OpEqPtr(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSSGTUconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSXOR, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpGeq16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16 x y) // cond: // result: (XORconst [1] (SGT (SignExt16to32 y) (SignExt16to32 x))) @@ -1590,20 +1578,24 @@ func rewriteValueMIPS_OpGeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGT, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(y) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(x) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpGeq16U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16U x y) // cond: // result: (XORconst [1] (SGTU (ZeroExt16to32 y) (ZeroExt16to32 x))) @@ -1612,20 +1604,24 @@ func rewriteValueMIPS_OpGeq16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGTU, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(x) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpGeq32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGeq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq32 x y) // cond: // result: (XORconst [1] (SGT y x)) @@ -1634,14 +1630,14 @@ func rewriteValueMIPS_OpGeq32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGT, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool()) v0.AddArg(y) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpGeq32F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGeq32F(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -1658,9 +1654,13 @@ func rewriteValueMIPS_OpGeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpGeq32U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGeq32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq32U x y) // cond: // result: (XORconst [1] (SGTU y x)) @@ -1669,14 +1669,14 @@ func rewriteValueMIPS_OpGeq32U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGTU, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool()) v0.AddArg(y) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpGeq64F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGeq64F(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -1693,9 +1693,13 @@ func rewriteValueMIPS_OpGeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpGeq8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8 x y) // cond: // result: (XORconst [1] (SGT (SignExt8to32 y) (SignExt8to32 x))) @@ -1704,20 +1708,24 @@ func rewriteValueMIPS_OpGeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGT, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(y) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(x) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpGeq8U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8U x y) // cond: // result: (XORconst [1] (SGTU (ZeroExt8to32 y) (ZeroExt8to32 x))) @@ -1726,20 +1734,18 @@ func rewriteValueMIPS_OpGeq8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGTU, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(x) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpGetClosurePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -1748,9 +1754,13 @@ func rewriteValueMIPS_OpGetClosurePtr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpGreater16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGreater16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16 x y) // cond: // result: (SGT (SignExt16to32 x) (SignExt16to32 y)) @@ -1758,18 +1768,22 @@ func rewriteValueMIPS_OpGreater16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGT) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS_OpGreater16U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGreater16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16U x y) // cond: // result: (SGTU (ZeroExt16to32 x) (ZeroExt16to32 y)) @@ -1777,18 +1791,16 @@ func rewriteValueMIPS_OpGreater16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS_OpGreater32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpGreater32(v *Value) bool { // match: (Greater32 x y) // cond: // result: (SGT x y) @@ -1801,7 +1813,7 @@ func rewriteValueMIPS_OpGreater32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpGreater32F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGreater32F(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -1818,9 +1830,7 @@ func rewriteValueMIPS_OpGreater32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpGreater32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpGreater32U(v *Value) bool { // match: (Greater32U x y) // cond: // result: (SGTU x y) @@ -1833,7 +1843,7 @@ func rewriteValueMIPS_OpGreater32U(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpGreater64F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGreater64F(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -1850,9 +1860,13 @@ func rewriteValueMIPS_OpGreater64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpGreater8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGreater8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8 x y) // cond: // result: (SGT (SignExt8to32 x) (SignExt8to32 y)) @@ -1860,18 +1874,22 @@ func rewriteValueMIPS_OpGreater8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGT) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS_OpGreater8U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpGreater8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8U x y) // cond: // result: (SGTU (ZeroExt8to32 x) (ZeroExt8to32 y)) @@ -1879,18 +1897,22 @@ func rewriteValueMIPS_OpGreater8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS_OpHmul32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpHmul32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul32 x y) // cond: // result: (Select0 (MULT x y)) @@ -1898,16 +1920,20 @@ func rewriteValueMIPS_OpHmul32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPSMULT, MakeTuple(config.fe.TypeInt32(), config.fe.TypeInt32())) + v0 := b.NewValue0(v.Pos, OpMIPSMULT, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpHmul32u(v *Value, config *Config) bool { +func rewriteValueMIPS_OpHmul32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul32u x y) // cond: // result: (Select0 (MULTU x y)) @@ -1915,16 +1941,14 @@ func rewriteValueMIPS_OpHmul32u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) + v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpInterCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpInterCall(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -1939,9 +1963,7 @@ func rewriteValueMIPS_OpInterCall(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpIsInBounds(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpIsInBounds(v *Value) bool { // match: (IsInBounds idx len) // cond: // result: (SGTU len idx) @@ -1954,9 +1976,13 @@ func rewriteValueMIPS_OpIsInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpIsNonNil(v *Value, config *Config) bool { +func rewriteValueMIPS_OpIsNonNil(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (IsNonNil ptr) // cond: // result: (SGTU ptr (MOVWconst [0])) @@ -1964,15 +1990,19 @@ func rewriteValueMIPS_OpIsNonNil(v *Value, config *Config) bool { ptr := v.Args[0] v.reset(OpMIPSSGTU) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) return true } } -func rewriteValueMIPS_OpIsSliceInBounds(v *Value, config *Config) bool { +func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (IsSliceInBounds idx len) // cond: // result: (XORconst [1] (SGTU idx len)) @@ -1981,16 +2011,20 @@ func rewriteValueMIPS_OpIsSliceInBounds(v *Value, config *Config) bool { len := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGTU, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool()) v0.AddArg(idx) v0.AddArg(len) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpLeq16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16 x y) // cond: // result: (XORconst [1] (SGT (SignExt16to32 x) (SignExt16to32 y))) @@ -1999,20 +2033,24 @@ func rewriteValueMIPS_OpLeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGT, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpLeq16U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16U x y) // cond: // result: (XORconst [1] (SGTU (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -2021,20 +2059,24 @@ func rewriteValueMIPS_OpLeq16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGTU, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpLeq32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLeq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq32 x y) // cond: // result: (XORconst [1] (SGT x y)) @@ -2043,14 +2085,14 @@ func rewriteValueMIPS_OpLeq32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGT, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpLeq32F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLeq32F(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -2067,9 +2109,13 @@ func rewriteValueMIPS_OpLeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpLeq32U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLeq32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq32U x y) // cond: // result: (XORconst [1] (SGTU x y)) @@ -2078,14 +2124,14 @@ func rewriteValueMIPS_OpLeq32U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGTU, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpLeq64F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLeq64F(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -2102,9 +2148,13 @@ func rewriteValueMIPS_OpLeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpLeq8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8 x y) // cond: // result: (XORconst [1] (SGT (SignExt8to32 x) (SignExt8to32 y))) @@ -2113,20 +2163,24 @@ func rewriteValueMIPS_OpLeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGT, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpLeq8U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8U x y) // cond: // result: (XORconst [1] (SGTU (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -2135,20 +2189,24 @@ func rewriteValueMIPS_OpLeq8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSXORconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpMIPSSGTU, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpLess16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLess16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16 x y) // cond: // result: (SGT (SignExt16to32 y) (SignExt16to32 x)) @@ -2156,18 +2214,22 @@ func rewriteValueMIPS_OpLess16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGT) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS_OpLess16U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLess16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16U x y) // cond: // result: (SGTU (ZeroExt16to32 y) (ZeroExt16to32 x)) @@ -2175,18 +2237,16 @@ func rewriteValueMIPS_OpLess16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS_OpLess32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpLess32(v *Value) bool { // match: (Less32 x y) // cond: // result: (SGT y x) @@ -2199,7 +2259,7 @@ func rewriteValueMIPS_OpLess32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpLess32F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLess32F(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -2216,9 +2276,7 @@ func rewriteValueMIPS_OpLess32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpLess32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpLess32U(v *Value) bool { // match: (Less32U x y) // cond: // result: (SGTU y x) @@ -2231,7 +2289,7 @@ func rewriteValueMIPS_OpLess32U(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpLess64F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLess64F(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -2248,9 +2306,13 @@ func rewriteValueMIPS_OpLess64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpLess8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLess8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8 x y) // cond: // result: (SGT (SignExt8to32 y) (SignExt8to32 x)) @@ -2258,18 +2320,22 @@ func rewriteValueMIPS_OpLess8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGT) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS_OpLess8U(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLess8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8U x y) // cond: // result: (SGTU (ZeroExt8to32 y) (ZeroExt8to32 x)) @@ -2277,18 +2343,16 @@ func rewriteValueMIPS_OpLess8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS_OpLoad(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpLoad(v *Value) bool { // match: (Load <t> ptr mem) // cond: t.IsBoolean() // result: (MOVBUload ptr mem) @@ -2411,9 +2475,13 @@ func rewriteValueMIPS_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpLsh16x16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x16 <t> x y) // cond: // result: (CMOVZ (SLL <t> x (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y))) @@ -2424,25 +2492,29 @@ func rewriteValueMIPS_OpLsh16x16(v *Value, config *Config) bool { v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpLsh16x32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x32 <t> x y) // cond: // result: (CMOVZ (SLL <t> x y) (MOVWconst [0]) (SGTUconst [32] y)) @@ -2455,19 +2527,17 @@ func rewriteValueMIPS_OpLsh16x32(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = 0 v.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v2.AuxInt = 32 v2.AddArg(y) v.AddArg(v2) return true } } -func rewriteValueMIPS_OpLsh16x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpLsh16x64(v *Value) bool { // match: (Lsh16x64 x (Const64 [c])) // cond: uint32(c) < 16 // result: (SLLconst x [c]) @@ -2504,9 +2574,13 @@ func rewriteValueMIPS_OpLsh16x64(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpLsh16x8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x8 <t> x y) // cond: // result: (CMOVZ (SLL <t> x (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y))) @@ -2517,25 +2591,29 @@ func rewriteValueMIPS_OpLsh16x8(v *Value, config *Config) bool { v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpLsh32x16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x16 <t> x y) // cond: // result: (CMOVZ (SLL <t> x (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y))) @@ -2546,25 +2624,29 @@ func rewriteValueMIPS_OpLsh32x16(v *Value, config *Config) bool { v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpLsh32x32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLsh32x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x32 <t> x y) // cond: // result: (CMOVZ (SLL <t> x y) (MOVWconst [0]) (SGTUconst [32] y)) @@ -2577,19 +2659,17 @@ func rewriteValueMIPS_OpLsh32x32(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = 0 v.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v2.AuxInt = 32 v2.AddArg(y) v.AddArg(v2) return true } } -func rewriteValueMIPS_OpLsh32x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpLsh32x64(v *Value) bool { // match: (Lsh32x64 x (Const64 [c])) // cond: uint32(c) < 32 // result: (SLLconst x [c]) @@ -2626,9 +2706,13 @@ func rewriteValueMIPS_OpLsh32x64(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpLsh32x8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x8 <t> x y) // cond: // result: (CMOVZ (SLL <t> x (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y))) @@ -2639,25 +2723,29 @@ func rewriteValueMIPS_OpLsh32x8(v *Value, config *Config) bool { v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpLsh8x16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x16 <t> x y) // cond: // result: (CMOVZ (SLL <t> x (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y))) @@ -2668,25 +2756,29 @@ func rewriteValueMIPS_OpLsh8x16(v *Value, config *Config) bool { v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpLsh8x32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x32 <t> x y) // cond: // result: (CMOVZ (SLL <t> x y) (MOVWconst [0]) (SGTUconst [32] y)) @@ -2699,19 +2791,17 @@ func rewriteValueMIPS_OpLsh8x32(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = 0 v.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v2.AuxInt = 32 v2.AddArg(y) v.AddArg(v2) return true } } -func rewriteValueMIPS_OpLsh8x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpLsh8x64(v *Value) bool { // match: (Lsh8x64 x (Const64 [c])) // cond: uint32(c) < 8 // result: (SLLconst x [c]) @@ -2748,9 +2838,13 @@ func rewriteValueMIPS_OpLsh8x64(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpLsh8x8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpLsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x8 <t> x y) // cond: // result: (CMOVZ (SLL <t> x (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y))) @@ -2761,25 +2855,23 @@ func rewriteValueMIPS_OpLsh8x8(v *Value, config *Config) bool { v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSLL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpMIPSADD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSADD(v *Value) bool { // match: (ADD (MOVWconst [c]) x) // cond: // result: (ADDconst [c] x) @@ -2842,9 +2934,7 @@ func rewriteValueMIPS_OpMIPSADD(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSADDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool { // match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr)) // cond: // result: (MOVWaddr [off1+off2] {sym} ptr) @@ -2924,7 +3014,7 @@ func rewriteValueMIPS_OpMIPSADDconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSAND(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMIPSAND(v *Value) bool { b := v.Block _ = b // match: (AND (MOVWconst [c]) x) @@ -3000,9 +3090,7 @@ func rewriteValueMIPS_OpMIPSAND(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSANDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool { // match: (ANDconst [0] _) // cond: // result: (MOVWconst [0]) @@ -3059,7 +3147,7 @@ func rewriteValueMIPS_OpMIPSANDconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSCMOVZ(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool { b := v.Block _ = b // match: (CMOVZ _ b (MOVWconst [0])) @@ -3117,9 +3205,7 @@ func rewriteValueMIPS_OpMIPSCMOVZ(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool { // match: (CMOVZzero _ (MOVWconst [0])) // cond: // result: (MOVWconst [0]) @@ -3155,9 +3241,7 @@ func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool { // match: (LoweredAtomicAdd ptr (MOVWconst [c]) mem) // cond: is16Bit(c) // result: (LoweredAtomicAddconst [c] ptr mem) @@ -3180,9 +3264,7 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSLoweredAtomicStore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSLoweredAtomicStore(v *Value) bool { // match: (LoweredAtomicStore ptr (MOVWconst [0]) mem) // cond: // result: (LoweredAtomicStorezero ptr mem) @@ -3203,9 +3285,7 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicStore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool { // match: (MOVBUload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVBUload [off1+off2] {sym} ptr mem) @@ -3278,7 +3358,7 @@ func rewriteValueMIPS_OpMIPSMOVBUload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool { b := v.Block _ = b // match: (MOVBUreg x:(MOVBUload _ _)) @@ -3361,9 +3441,7 @@ func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool { // match: (MOVBload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -3436,7 +3514,7 @@ func rewriteValueMIPS_OpMIPSMOVBload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBreg(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool { b := v.Block _ = b // match: (MOVBreg x:(MOVBload _ _)) @@ -3522,9 +3600,7 @@ func rewriteValueMIPS_OpMIPSMOVBreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool { // match: (MOVBstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVBstore [off1+off2] {sym} ptr val mem) @@ -3705,9 +3781,7 @@ func rewriteValueMIPS_OpMIPSMOVBstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool { // match: (MOVBstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVBstorezero [off1+off2] {sym} ptr mem) @@ -3757,9 +3831,7 @@ func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool { // match: (MOVDload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVDload [off1+off2] {sym} ptr mem) @@ -3832,9 +3904,7 @@ func rewriteValueMIPS_OpMIPSMOVDload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool { // match: (MOVDstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -3888,9 +3958,7 @@ func rewriteValueMIPS_OpMIPSMOVDstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVFload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool { // match: (MOVFload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVFload [off1+off2] {sym} ptr mem) @@ -3963,9 +4031,7 @@ func rewriteValueMIPS_OpMIPSMOVFload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVFstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool { // match: (MOVFstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVFstore [off1+off2] {sym} ptr val mem) @@ -4019,9 +4085,7 @@ func rewriteValueMIPS_OpMIPSMOVFstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool { // match: (MOVHUload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVHUload [off1+off2] {sym} ptr mem) @@ -4094,7 +4158,7 @@ func rewriteValueMIPS_OpMIPSMOVHUload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool { b := v.Block _ = b // match: (MOVHUreg x:(MOVBUload _ _)) @@ -4201,9 +4265,7 @@ func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool { // match: (MOVHload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -4276,7 +4338,7 @@ func rewriteValueMIPS_OpMIPSMOVHload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHreg(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool { b := v.Block _ = b // match: (MOVHreg x:(MOVBload _ _)) @@ -4410,9 +4472,7 @@ func rewriteValueMIPS_OpMIPSMOVHreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool { // match: (MOVHstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVHstore [off1+off2] {sym} ptr val mem) @@ -4551,9 +4611,7 @@ func rewriteValueMIPS_OpMIPSMOVHstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool { // match: (MOVHstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVHstorezero [off1+off2] {sym} ptr mem) @@ -4603,9 +4661,7 @@ func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVWload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool { // match: (MOVWload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVWload [off1+off2] {sym} ptr mem) @@ -4678,9 +4734,7 @@ func rewriteValueMIPS_OpMIPSMOVWload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVWreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool { // match: (MOVWreg x) // cond: x.Uses == 1 // result: (MOVWnop x) @@ -4708,9 +4762,7 @@ func rewriteValueMIPS_OpMIPSMOVWreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVWstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool { // match: (MOVWstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVWstore [off1+off2] {sym} ptr val mem) @@ -4807,9 +4859,7 @@ func rewriteValueMIPS_OpMIPSMOVWstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool { // match: (MOVWstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVWstorezero [off1+off2] {sym} ptr mem) @@ -4859,9 +4909,7 @@ func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSMUL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSMUL(v *Value) bool { // match: (MUL (MOVWconst [0]) _ ) // cond: // result: (MOVWconst [0]) @@ -4948,9 +4996,7 @@ func rewriteValueMIPS_OpMIPSMUL(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSNEG(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSNEG(v *Value) bool { // match: (NEG (MOVWconst [c])) // cond: // result: (MOVWconst [int64(int32(-c))]) @@ -4966,9 +5012,7 @@ func rewriteValueMIPS_OpMIPSNEG(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSNOR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSNOR(v *Value) bool { // match: (NOR (MOVWconst [c]) x) // cond: // result: (NORconst [c] x) @@ -5001,9 +5045,7 @@ func rewriteValueMIPS_OpMIPSNOR(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSNORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool { // match: (NORconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [^(c|d)]) @@ -5020,7 +5062,7 @@ func rewriteValueMIPS_OpMIPSNORconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSOR(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMIPSOR(v *Value) bool { b := v.Block _ = b // match: (OR (MOVWconst [c]) x) @@ -5089,9 +5131,7 @@ func rewriteValueMIPS_OpMIPSOR(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSORconst(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -5148,9 +5188,7 @@ func rewriteValueMIPS_OpMIPSORconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSGT(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSGT(v *Value) bool { // match: (SGT (MOVWconst [c]) x) // cond: // result: (SGTconst [c] x) @@ -5184,9 +5222,7 @@ func rewriteValueMIPS_OpMIPSSGT(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool { // match: (SGTU (MOVWconst [c]) x) // cond: // result: (SGTUconst [c] x) @@ -5220,9 +5256,7 @@ func rewriteValueMIPS_OpMIPSSGTU(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTUconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool { // match: (SGTUconst [c] (MOVWconst [d])) // cond: uint32(c)>uint32(d) // result: (MOVWconst [1]) @@ -5325,9 +5359,7 @@ func rewriteValueMIPS_OpMIPSSGTUconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTUzero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool { // match: (SGTUzero (MOVWconst [d])) // cond: uint32(d) != 0 // result: (MOVWconst [1]) @@ -5362,9 +5394,7 @@ func rewriteValueMIPS_OpMIPSSGTUzero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool { // match: (SGTconst [c] (MOVWconst [d])) // cond: int32(c) > int32(d) // result: (MOVWconst [1]) @@ -5563,9 +5593,7 @@ func rewriteValueMIPS_OpMIPSSGTconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTzero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool { // match: (SGTzero (MOVWconst [d])) // cond: int32(d) > 0 // result: (MOVWconst [1]) @@ -5600,9 +5628,7 @@ func rewriteValueMIPS_OpMIPSSGTzero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSLL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSLL(v *Value) bool { // match: (SLL _ (MOVWconst [c])) // cond: uint32(c)>=32 // result: (MOVWconst [0]) @@ -5636,9 +5662,7 @@ func rewriteValueMIPS_OpMIPSSLL(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSLLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSLLconst(v *Value) bool { // match: (SLLconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(int32(uint32(d)<<uint32(c)))]) @@ -5655,9 +5679,7 @@ func rewriteValueMIPS_OpMIPSSLLconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSRA(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSRA(v *Value) bool { // match: (SRA x (MOVWconst [c])) // cond: uint32(c)>=32 // result: (SRAconst x [31]) @@ -5693,9 +5715,7 @@ func rewriteValueMIPS_OpMIPSSRA(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSRAconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool { // match: (SRAconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(int32(d)>>uint32(c))]) @@ -5712,9 +5732,7 @@ func rewriteValueMIPS_OpMIPSSRAconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSRL(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSRL(v *Value) bool { // match: (SRL _ (MOVWconst [c])) // cond: uint32(c)>=32 // result: (MOVWconst [0]) @@ -5748,9 +5766,7 @@ func rewriteValueMIPS_OpMIPSSRL(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSRLconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool { // match: (SRLconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(uint32(d)>>uint32(c))]) @@ -5767,9 +5783,7 @@ func rewriteValueMIPS_OpMIPSSRLconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSUB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSUB(v *Value) bool { // match: (SUB x (MOVWconst [c])) // cond: // result: (SUBconst [c] x) @@ -5815,9 +5829,7 @@ func rewriteValueMIPS_OpMIPSSUB(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSSUBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool { // match: (SUBconst [0] x) // cond: // result: x @@ -5879,9 +5891,7 @@ func rewriteValueMIPS_OpMIPSSUBconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSXOR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSXOR(v *Value) bool { // match: (XOR (MOVWconst [c]) x) // cond: // result: (XORconst [c] x) @@ -5926,9 +5936,7 @@ func rewriteValueMIPS_OpMIPSXOR(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMIPSXORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -5987,9 +5995,13 @@ func rewriteValueMIPS_OpMIPSXORconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMod16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMod16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16 x y) // cond: // result: (Select0 (DIV (SignExt16to32 x) (SignExt16to32 y))) @@ -5997,20 +6009,24 @@ func rewriteValueMIPS_OpMod16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(config.fe.TypeInt32(), config.fe.TypeInt32())) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpMod16u(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMod16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16u x y) // cond: // result: (Select0 (DIVU (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -6018,20 +6034,24 @@ func rewriteValueMIPS_OpMod16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpMod32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMod32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32 x y) // cond: // result: (Select0 (DIV x y)) @@ -6039,16 +6059,20 @@ func rewriteValueMIPS_OpMod32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(config.fe.TypeInt32(), config.fe.TypeInt32())) + v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpMod32u(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMod32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32u x y) // cond: // result: (Select0 (DIVU x y)) @@ -6056,16 +6080,20 @@ func rewriteValueMIPS_OpMod32u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) + v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpMod8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMod8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8 x y) // cond: // result: (Select0 (DIV (SignExt8to32 x) (SignExt8to32 y))) @@ -6073,20 +6101,24 @@ func rewriteValueMIPS_OpMod8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(config.fe.TypeInt32(), config.fe.TypeInt32())) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpMod8u(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMod8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8u x y) // cond: // result: (Select0 (DIVU (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -6094,20 +6126,24 @@ func rewriteValueMIPS_OpMod8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { +func rewriteValueMIPS_OpMove(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Move [0] _ _ mem) // cond: // result: mem @@ -6133,7 +6169,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpMIPSMOVBstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -6156,7 +6192,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { } v.reset(OpMIPSMOVHstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVHUload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVHUload, fe.TypeUInt16()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -6176,14 +6212,14 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v.reset(OpMIPSMOVBstore) v.AuxInt = 1 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v0.AuxInt = 1 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -6207,7 +6243,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { } v.reset(OpMIPSMOVWstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -6231,14 +6267,14 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v.reset(OpMIPSMOVHstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVHUload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVHUload, fe.TypeUInt16()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPSMOVHUload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVHUload, fe.TypeUInt16()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -6259,7 +6295,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v.reset(OpMIPSMOVBstore) v.AuxInt = 3 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v0.AuxInt = 3 v0.AddArg(src) v0.AddArg(mem) @@ -6267,7 +6303,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v1.AuxInt = 2 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v2.AuxInt = 2 v2.AddArg(src) v2.AddArg(mem) @@ -6275,14 +6311,14 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v3.AuxInt = 1 v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v4.AuxInt = 1 v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v5.AddArg(dst) - v6 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v6 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v6.AddArg(src) v6.AddArg(mem) v5.AddArg(v6) @@ -6305,7 +6341,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v.reset(OpMIPSMOVBstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) @@ -6313,14 +6349,14 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v1.AuxInt = 1 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v2.AuxInt = 1 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -6346,14 +6382,14 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v.reset(OpMIPSMOVWstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -6378,7 +6414,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v.reset(OpMIPSMOVHstore) v.AuxInt = 6 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVHload, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16()) v0.AuxInt = 6 v0.AddArg(src) v0.AddArg(mem) @@ -6386,7 +6422,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem) v1.AuxInt = 4 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPSMOVHload, config.fe.TypeInt16()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16()) v2.AuxInt = 4 v2.AddArg(src) v2.AddArg(mem) @@ -6394,14 +6430,14 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem) v3.AuxInt = 2 v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPSMOVHload, config.fe.TypeInt16()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16()) v4.AuxInt = 2 v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem) v5.AddArg(dst) - v6 := b.NewValue0(v.Pos, OpMIPSMOVHload, config.fe.TypeInt16()) + v6 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16()) v6.AddArg(src) v6.AddArg(mem) v5.AddArg(v6) @@ -6428,7 +6464,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v.reset(OpMIPSMOVHstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVHload, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) @@ -6436,14 +6472,14 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem) v1.AuxInt = 2 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPSMOVHload, config.fe.TypeInt16()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16()) v2.AuxInt = 2 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPSMOVHload, config.fe.TypeInt16()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -6469,7 +6505,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v.reset(OpMIPSMOVWstore) v.AuxInt = 8 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v0.AuxInt = 8 v0.AddArg(src) v0.AddArg(mem) @@ -6477,14 +6513,14 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v1.AuxInt = 4 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v2.AuxInt = 4 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -6510,7 +6546,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v.reset(OpMIPSMOVWstore) v.AuxInt = 12 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v0.AuxInt = 12 v0.AddArg(src) v0.AddArg(mem) @@ -6518,7 +6554,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v1.AuxInt = 8 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v2.AuxInt = 8 v2.AddArg(src) v2.AddArg(mem) @@ -6526,14 +6562,14 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v3.AuxInt = 4 v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v4.AuxInt = 4 v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v5.AddArg(dst) - v6 := b.NewValue0(v.Pos, OpMIPSMOVWload, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32()) v6.AddArg(src) v6.AddArg(mem) v5.AddArg(v6) @@ -6568,9 +6604,7 @@ func rewriteValueMIPS_OpMove(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpMul16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMul16(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MUL x y) @@ -6583,9 +6617,7 @@ func rewriteValueMIPS_OpMul16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpMul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMul32(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MUL x y) @@ -6598,9 +6630,7 @@ func rewriteValueMIPS_OpMul32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpMul32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMul32F(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULF x y) @@ -6613,9 +6643,7 @@ func rewriteValueMIPS_OpMul32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpMul32uhilo(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMul32uhilo(v *Value) bool { // match: (Mul32uhilo x y) // cond: // result: (MULTU x y) @@ -6628,9 +6656,7 @@ func rewriteValueMIPS_OpMul32uhilo(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpMul64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMul64F(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULD x y) @@ -6643,9 +6669,7 @@ func rewriteValueMIPS_OpMul64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpMul8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpMul8(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MUL x y) @@ -6658,9 +6682,7 @@ func rewriteValueMIPS_OpMul8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNeg16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpNeg16(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEG x) @@ -6671,9 +6693,7 @@ func rewriteValueMIPS_OpNeg16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNeg32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpNeg32(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEG x) @@ -6684,9 +6704,7 @@ func rewriteValueMIPS_OpNeg32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNeg32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpNeg32F(v *Value) bool { // match: (Neg32F x) // cond: // result: (NEGF x) @@ -6697,9 +6715,7 @@ func rewriteValueMIPS_OpNeg32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNeg64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpNeg64F(v *Value) bool { // match: (Neg64F x) // cond: // result: (NEGD x) @@ -6710,9 +6726,7 @@ func rewriteValueMIPS_OpNeg64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNeg8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpNeg8(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEG x) @@ -6723,9 +6737,13 @@ func rewriteValueMIPS_OpNeg8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNeq16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpNeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq16 x y) // cond: // result: (SGTU (XOR (ZeroExt16to32 x) (ZeroExt16to32 y)) (MOVWconst [0])) @@ -6733,23 +6751,27 @@ func rewriteValueMIPS_OpNeq16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGTU) - v0 := b.NewValue0(v.Pos, OpMIPSXOR, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = 0 v.AddArg(v3) return true } } -func rewriteValueMIPS_OpNeq32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpNeq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq32 x y) // cond: // result: (SGTU (XOR x y) (MOVWconst [0])) @@ -6757,17 +6779,17 @@ func rewriteValueMIPS_OpNeq32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGTU) - v0 := b.NewValue0(v.Pos, OpMIPSXOR, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = 0 v.AddArg(v1) return true } } -func rewriteValueMIPS_OpNeq32F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpNeq32F(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -6784,7 +6806,7 @@ func rewriteValueMIPS_OpNeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNeq64F(v *Value, config *Config) bool { +func rewriteValueMIPS_OpNeq64F(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -6801,9 +6823,13 @@ func rewriteValueMIPS_OpNeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNeq8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpNeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq8 x y) // cond: // result: (SGTU (XOR (ZeroExt8to32 x) (ZeroExt8to32 y)) (MOVWconst [0])) @@ -6811,23 +6837,21 @@ func rewriteValueMIPS_OpNeq8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGTU) - v0 := b.NewValue0(v.Pos, OpMIPSXOR, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = 0 v.AddArg(v3) return true } } -func rewriteValueMIPS_OpNeqB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpNeqB(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -6840,9 +6864,13 @@ func rewriteValueMIPS_OpNeqB(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNeqPtr(v *Value, config *Config) bool { +func rewriteValueMIPS_OpNeqPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (NeqPtr x y) // cond: // result: (SGTU (XOR x y) (MOVWconst [0])) @@ -6850,19 +6878,17 @@ func rewriteValueMIPS_OpNeqPtr(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSGTU) - v0 := b.NewValue0(v.Pos, OpMIPSXOR, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = 0 v.AddArg(v1) return true } } -func rewriteValueMIPS_OpNilCheck(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpNilCheck(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -6875,9 +6901,7 @@ func rewriteValueMIPS_OpNilCheck(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpNot(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpNot(v *Value) bool { // match: (Not x) // cond: // result: (XORconst [1] x) @@ -6889,9 +6913,7 @@ func rewriteValueMIPS_OpNot(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpOffPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpOffPtr(v *Value) bool { // match: (OffPtr [off] ptr:(SP)) // cond: // result: (MOVWaddr [off] ptr) @@ -6918,9 +6940,7 @@ func rewriteValueMIPS_OpOffPtr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpOr16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpOr16(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -6933,9 +6953,7 @@ func rewriteValueMIPS_OpOr16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpOr32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpOr32(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -6948,9 +6966,7 @@ func rewriteValueMIPS_OpOr32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpOr8(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -6963,9 +6979,7 @@ func rewriteValueMIPS_OpOr8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpOrB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpOrB(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -6978,9 +6992,7 @@ func rewriteValueMIPS_OpOrB(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpRound32F(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -6992,9 +7004,7 @@ func rewriteValueMIPS_OpRound32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpRound64F(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -7006,9 +7016,13 @@ func rewriteValueMIPS_OpRound64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRsh16Ux16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux16 <t> x y) // cond: // result: (CMOVZ (SRL <t> (ZeroExt16to32 x) (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y))) @@ -7018,28 +7032,32 @@ func rewriteValueMIPS_OpRsh16Ux16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = 0 v.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v4.AuxInt = 32 - v5 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS_OpRsh16Ux32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux32 <t> x y) // cond: // result: (CMOVZ (SRL <t> (ZeroExt16to32 x) y) (MOVWconst [0]) (SGTUconst [32] y)) @@ -7049,27 +7067,31 @@ func rewriteValueMIPS_OpRsh16Ux32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 v3.AddArg(y) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpRsh16Ux64(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux64 x (Const64 [c])) // cond: uint32(c) < 16 - // result: (SRLconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) + // result: (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) for { x := v.Args[0] v_1 := v.Args[1] @@ -7082,7 +7104,7 @@ func rewriteValueMIPS_OpRsh16Ux64(v *Value, config *Config) bool { } v.reset(OpMIPSSRLconst) v.AuxInt = c + 16 - v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v0.AuxInt = 16 v0.AddArg(x) v.AddArg(v0) @@ -7106,9 +7128,13 @@ func rewriteValueMIPS_OpRsh16Ux64(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpRsh16Ux8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux8 <t> x y) // cond: // result: (CMOVZ (SRL <t> (ZeroExt16to32 x) (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y))) @@ -7118,48 +7144,52 @@ func rewriteValueMIPS_OpRsh16Ux8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = 0 v.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v4.AuxInt = 32 - v5 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS_OpRsh16x16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x16 x y) // cond: - // result: (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) + // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = -1 v1.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v4.AuxInt = 32 - v5 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -7167,25 +7197,29 @@ func rewriteValueMIPS_OpRsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRsh16x32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x32 x y) // cond: - // result: (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) + // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = -1 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 v3.AddArg(y) v1.AddArg(v3) @@ -7193,12 +7227,16 @@ func rewriteValueMIPS_OpRsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRsh16x64(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x64 x (Const64 [c])) // cond: uint32(c) < 16 - // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) + // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) for { x := v.Args[0] v_1 := v.Args[1] @@ -7211,7 +7249,7 @@ func rewriteValueMIPS_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpMIPSSRAconst) v.AuxInt = c + 16 - v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v0.AuxInt = 16 v0.AddArg(x) v.AddArg(v0) @@ -7219,7 +7257,7 @@ func rewriteValueMIPS_OpRsh16x64(v *Value, config *Config) bool { } // match: (Rsh16x64 x (Const64 [c])) // cond: uint32(c) >= 16 - // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [31]) + // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31]) for { x := v.Args[0] v_1 := v.Args[1] @@ -7232,7 +7270,7 @@ func rewriteValueMIPS_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpMIPSSRAconst) v.AuxInt = 31 - v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v0.AuxInt = 16 v0.AddArg(x) v.AddArg(v0) @@ -7240,29 +7278,33 @@ func rewriteValueMIPS_OpRsh16x64(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpRsh16x8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x8 x y) // cond: - // result: (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) + // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = -1 v1.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v4.AuxInt = 32 - v5 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -7270,9 +7312,13 @@ func rewriteValueMIPS_OpRsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRsh32Ux16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux16 <t> x y) // cond: // result: (CMOVZ (SRL <t> x (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y))) @@ -7283,25 +7329,29 @@ func rewriteValueMIPS_OpRsh32Ux16(v *Value, config *Config) bool { v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSRL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpRsh32Ux32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux32 <t> x y) // cond: // result: (CMOVZ (SRL <t> x y) (MOVWconst [0]) (SGTUconst [32] y)) @@ -7314,19 +7364,17 @@ func rewriteValueMIPS_OpRsh32Ux32(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = 0 v.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v2.AuxInt = 32 v2.AddArg(y) v.AddArg(v2) return true } } -func rewriteValueMIPS_OpRsh32Ux64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool { // match: (Rsh32Ux64 x (Const64 [c])) // cond: uint32(c) < 32 // result: (SRLconst x [c]) @@ -7363,9 +7411,13 @@ func rewriteValueMIPS_OpRsh32Ux64(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpRsh32Ux8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux8 <t> x y) // cond: // result: (CMOVZ (SRL <t> x (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y))) @@ -7376,43 +7428,47 @@ func rewriteValueMIPS_OpRsh32Ux8(v *Value, config *Config) bool { v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSRL, t) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpRsh32x16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x16 x y) // cond: - // result: (SRA x ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) + // result: (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSRA) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = -1 v0.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v0.AddArg(v3) @@ -7420,23 +7476,27 @@ func rewriteValueMIPS_OpRsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRsh32x32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh32x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x32 x y) // cond: - // result: (SRA x ( CMOVZ <config.fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) + // result: (SRA x ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSRA) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = -1 v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v2.AuxInt = 32 v2.AddArg(y) v0.AddArg(v2) @@ -7444,9 +7504,7 @@ func rewriteValueMIPS_OpRsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRsh32x64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpRsh32x64(v *Value) bool { // match: (Rsh32x64 x (Const64 [c])) // cond: uint32(c) < 32 // result: (SRAconst x [c]) @@ -7485,27 +7543,31 @@ func rewriteValueMIPS_OpRsh32x64(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpRsh32x8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x8 x y) // cond: - // result: (SRA x ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) + // result: (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSRA) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = -1 v0.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 - v4 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v4.AddArg(y) v3.AddArg(v4) v0.AddArg(v3) @@ -7513,9 +7575,13 @@ func rewriteValueMIPS_OpRsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRsh8Ux16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux16 <t> x y) // cond: // result: (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y))) @@ -7525,28 +7591,32 @@ func rewriteValueMIPS_OpRsh8Ux16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = 0 v.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v4.AuxInt = 32 - v5 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS_OpRsh8Ux32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux32 <t> x y) // cond: // result: (CMOVZ (SRL <t> (ZeroExt8to32 x) y) (MOVWconst [0]) (SGTUconst [32] y)) @@ -7556,27 +7626,31 @@ func rewriteValueMIPS_OpRsh8Ux32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 v3.AddArg(y) v.AddArg(v3) return true } } -func rewriteValueMIPS_OpRsh8Ux64(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux64 x (Const64 [c])) // cond: uint32(c) < 8 - // result: (SRLconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) + // result: (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) for { x := v.Args[0] v_1 := v.Args[1] @@ -7589,7 +7663,7 @@ func rewriteValueMIPS_OpRsh8Ux64(v *Value, config *Config) bool { } v.reset(OpMIPSSRLconst) v.AuxInt = c + 24 - v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v0.AuxInt = 24 v0.AddArg(x) v.AddArg(v0) @@ -7613,9 +7687,13 @@ func rewriteValueMIPS_OpRsh8Ux64(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpRsh8Ux8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux8 <t> x y) // cond: // result: (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y))) @@ -7625,48 +7703,52 @@ func rewriteValueMIPS_OpRsh8Ux8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpMIPSCMOVZ) v0 := b.NewValue0(v.Pos, OpMIPSSRL, t) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = 0 v.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v4.AuxInt = 32 - v5 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS_OpRsh8x16(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x16 x y) // cond: - // result: (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) + // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = -1 v1.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v4.AuxInt = 32 - v5 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -7674,25 +7756,29 @@ func rewriteValueMIPS_OpRsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRsh8x32(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x32 x y) // cond: - // result: (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) + // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = -1 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v3.AuxInt = 32 v3.AddArg(y) v1.AddArg(v3) @@ -7700,12 +7786,16 @@ func rewriteValueMIPS_OpRsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpRsh8x64(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x64 x (Const64 [c])) // cond: uint32(c) < 8 - // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) + // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) for { x := v.Args[0] v_1 := v.Args[1] @@ -7718,7 +7808,7 @@ func rewriteValueMIPS_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpMIPSSRAconst) v.AuxInt = c + 24 - v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v0.AuxInt = 24 v0.AddArg(x) v.AddArg(v0) @@ -7726,7 +7816,7 @@ func rewriteValueMIPS_OpRsh8x64(v *Value, config *Config) bool { } // match: (Rsh8x64 x (Const64 [c])) // cond: uint32(c) >= 8 - // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [31]) + // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31]) for { x := v.Args[0] v_1 := v.Args[1] @@ -7739,7 +7829,7 @@ func rewriteValueMIPS_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpMIPSSRAconst) v.AuxInt = 31 - v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32()) v0.AuxInt = 24 v0.AddArg(x) v.AddArg(v0) @@ -7747,29 +7837,33 @@ func rewriteValueMIPS_OpRsh8x64(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpRsh8x8(v *Value, config *Config) bool { +func rewriteValueMIPS_OpRsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x8 x y) // cond: - // result: (SRA (SignExt16to32 x) ( CMOVZ <config.fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) + // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPSSRA) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v3.AuxInt = -1 v1.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, config.fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool()) v4.AuxInt = 32 - v5 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v5.AddArg(y) v4.AddArg(v5) v1.AddArg(v4) @@ -7777,9 +7871,13 @@ func rewriteValueMIPS_OpRsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSelect0(v *Value, config *Config) bool { +func rewriteValueMIPS_OpSelect0(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Select0 (Add32carry <t> x y)) // cond: // result: (ADD <t.FieldType(0)> x y) @@ -7832,8 +7930,8 @@ func rewriteValueMIPS_OpSelect0(v *Value, config *Config) bool { break } v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = c v0.AddArg(v1) v0.AddArg(x) @@ -7899,7 +7997,7 @@ func rewriteValueMIPS_OpSelect0(v *Value, config *Config) bool { v0.AuxInt = -1 v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = 0 v.AddArg(v1) v.AddArg(x) @@ -7995,12 +8093,16 @@ func rewriteValueMIPS_OpSelect0(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpSelect1(v *Value, config *Config) bool { +func rewriteValueMIPS_OpSelect1(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Select1 (Add32carry <t> x y)) // cond: - // result: (SGTU <config.fe.TypeBool()> x (ADD <t.FieldType(0)> x y)) + // result: (SGTU <fe.TypeBool()> x (ADD <t.FieldType(0)> x y)) for { v_0 := v.Args[0] if v_0.Op != OpAdd32carry { @@ -8010,7 +8112,7 @@ func rewriteValueMIPS_OpSelect1(v *Value, config *Config) bool { x := v_0.Args[0] y := v_0.Args[1] v.reset(OpMIPSSGTU) - v.Type = config.fe.TypeBool() + v.Type = fe.TypeBool() v.AddArg(x) v0 := b.NewValue0(v.Pos, OpMIPSADD, t.FieldType(0)) v0.AddArg(x) @@ -8020,7 +8122,7 @@ func rewriteValueMIPS_OpSelect1(v *Value, config *Config) bool { } // match: (Select1 (Sub32carry <t> x y)) // cond: - // result: (SGTU <config.fe.TypeBool()> (SUB <t.FieldType(0)> x y) x) + // result: (SGTU <fe.TypeBool()> (SUB <t.FieldType(0)> x y) x) for { v_0 := v.Args[0] if v_0.Op != OpSub32carry { @@ -8030,7 +8132,7 @@ func rewriteValueMIPS_OpSelect1(v *Value, config *Config) bool { x := v_0.Args[0] y := v_0.Args[1] v.reset(OpMIPSSGTU) - v.Type = config.fe.TypeBool() + v.Type = fe.TypeBool() v0 := b.NewValue0(v.Pos, OpMIPSSUB, t.FieldType(0)) v0.AddArg(x) v0.AddArg(y) @@ -8056,8 +8158,8 @@ func rewriteValueMIPS_OpSelect1(v *Value, config *Config) bool { break } v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = c v0.AddArg(v1) v0.AddArg(x) @@ -8215,9 +8317,7 @@ func rewriteValueMIPS_OpSelect1(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpSignExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSignExt16to32(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -8228,9 +8328,7 @@ func rewriteValueMIPS_OpSignExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSignExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSignExt8to16(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -8241,9 +8339,7 @@ func rewriteValueMIPS_OpSignExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSignExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSignExt8to32(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -8254,9 +8350,7 @@ func rewriteValueMIPS_OpSignExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSignmask(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSignmask(v *Value) bool { // match: (Signmask x) // cond: // result: (SRAconst x [31]) @@ -8268,7 +8362,7 @@ func rewriteValueMIPS_OpSignmask(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSlicemask(v *Value, config *Config) bool { +func rewriteValueMIPS_OpSlicemask(v *Value) bool { b := v.Block _ = b // match: (Slicemask <t> x) @@ -8285,9 +8379,7 @@ func rewriteValueMIPS_OpSlicemask(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSqrt(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSqrt(v *Value) bool { // match: (Sqrt x) // cond: // result: (SQRTD x) @@ -8298,9 +8390,7 @@ func rewriteValueMIPS_OpSqrt(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpStaticCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpStaticCall(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -8315,9 +8405,7 @@ func rewriteValueMIPS_OpStaticCall(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpStore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpStore(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 1 // result: (MOVBstore ptr val mem) @@ -8405,9 +8493,7 @@ func rewriteValueMIPS_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpSub16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSub16(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUB x y) @@ -8420,9 +8506,7 @@ func rewriteValueMIPS_OpSub16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSub32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSub32(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUB x y) @@ -8435,9 +8519,7 @@ func rewriteValueMIPS_OpSub32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSub32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSub32F(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBF x y) @@ -8450,7 +8532,7 @@ func rewriteValueMIPS_OpSub32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSub32withcarry(v *Value, config *Config) bool { +func rewriteValueMIPS_OpSub32withcarry(v *Value) bool { b := v.Block _ = b // match: (Sub32withcarry <t> x y c) @@ -8470,9 +8552,7 @@ func rewriteValueMIPS_OpSub32withcarry(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSub64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSub64F(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBD x y) @@ -8485,9 +8565,7 @@ func rewriteValueMIPS_OpSub64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSub8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSub8(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUB x y) @@ -8500,9 +8578,7 @@ func rewriteValueMIPS_OpSub8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpSubPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpSubPtr(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -8515,9 +8591,7 @@ func rewriteValueMIPS_OpSubPtr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpTrunc16to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpTrunc16to8(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -8529,9 +8603,7 @@ func rewriteValueMIPS_OpTrunc16to8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpTrunc32to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpTrunc32to16(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -8543,9 +8615,7 @@ func rewriteValueMIPS_OpTrunc32to16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpTrunc32to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpTrunc32to8(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -8557,9 +8627,7 @@ func rewriteValueMIPS_OpTrunc32to8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpXor16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpXor16(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -8572,9 +8640,7 @@ func rewriteValueMIPS_OpXor16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpXor32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpXor32(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -8587,9 +8653,7 @@ func rewriteValueMIPS_OpXor32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpXor8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpXor8(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -8602,9 +8666,13 @@ func rewriteValueMIPS_OpXor8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { +func rewriteValueMIPS_OpZero(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Zero [0] _ mem) // cond: // result: mem @@ -8629,7 +8697,7 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { mem := v.Args[1] v.reset(OpMIPSMOVBstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -8650,7 +8718,7 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { } v.reset(OpMIPSMOVHstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -8668,13 +8736,13 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { v.reset(OpMIPSMOVBstore) v.AuxInt = 1 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v1.AuxInt = 0 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -8696,7 +8764,7 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { } v.reset(OpMIPSMOVWstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -8718,13 +8786,13 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { v.reset(OpMIPSMOVHstore) v.AuxInt = 2 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem) v1.AuxInt = 0 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -8743,25 +8811,25 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { v.reset(OpMIPSMOVBstore) v.AuxInt = 3 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v1.AuxInt = 2 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v3.AuxInt = 1 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v4.AuxInt = 0 v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v5.AuxInt = 0 v5.AddArg(ptr) - v6 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v6.AuxInt = 0 v5.AddArg(v6) v5.AddArg(mem) @@ -8782,19 +8850,19 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { v.reset(OpMIPSMOVBstore) v.AuxInt = 2 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v1.AuxInt = 1 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem) v3.AuxInt = 0 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -8818,19 +8886,19 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { v.reset(OpMIPSMOVHstore) v.AuxInt = 4 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem) v1.AuxInt = 2 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem) v3.AuxInt = 0 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -8854,13 +8922,13 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { v.reset(OpMIPSMOVWstore) v.AuxInt = 4 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v1.AuxInt = 0 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -8883,19 +8951,19 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { v.reset(OpMIPSMOVWstore) v.AuxInt = 8 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v1.AuxInt = 4 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v3.AuxInt = 0 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -8919,25 +8987,25 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { v.reset(OpMIPSMOVWstore) v.AuxInt = 12 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v1.AuxInt = 8 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v3.AuxInt = 4 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v4.AuxInt = 0 v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem) v5.AuxInt = 0 v5.AddArg(ptr) - v6 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v6.AuxInt = 0 v5.AddArg(v6) v5.AddArg(mem) @@ -8969,9 +9037,7 @@ func rewriteValueMIPS_OpZero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS_OpZeroExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHUreg x) @@ -8982,9 +9048,7 @@ func rewriteValueMIPS_OpZeroExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpZeroExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBUreg x) @@ -8995,9 +9059,7 @@ func rewriteValueMIPS_OpZeroExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpZeroExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBUreg x) @@ -9008,25 +9070,33 @@ func rewriteValueMIPS_OpZeroExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS_OpZeromask(v *Value, config *Config) bool { +func rewriteValueMIPS_OpZeromask(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Zeromask x) // cond: // result: (NEG (SGTU x (MOVWconst [0]))) for { x := v.Args[0] v.reset(OpMIPSNEG) - v0 := b.NewValue0(v.Pos, OpMIPSSGTU, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool()) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32()) v1.AuxInt = 0 v0.AddArg(v1) v.AddArg(v0) return true } } -func rewriteBlockMIPS(b *Block, config *Config) bool { +func rewriteBlockMIPS(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { case BlockMIPSEQ: // match: (EQ (FPFlagTrue cmp) yes no) diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS64.go b/src/cmd/compile/internal/ssa/rewriteMIPS64.go index 983bde3a20..ab1c6ab592 100644 --- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go +++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go @@ -6,568 +6,566 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValueMIPS64(v *Value, config *Config) bool { +func rewriteValueMIPS64(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValueMIPS64_OpAdd16(v, config) + return rewriteValueMIPS64_OpAdd16(v) case OpAdd32: - return rewriteValueMIPS64_OpAdd32(v, config) + return rewriteValueMIPS64_OpAdd32(v) case OpAdd32F: - return rewriteValueMIPS64_OpAdd32F(v, config) + return rewriteValueMIPS64_OpAdd32F(v) case OpAdd64: - return rewriteValueMIPS64_OpAdd64(v, config) + return rewriteValueMIPS64_OpAdd64(v) case OpAdd64F: - return rewriteValueMIPS64_OpAdd64F(v, config) + return rewriteValueMIPS64_OpAdd64F(v) case OpAdd8: - return rewriteValueMIPS64_OpAdd8(v, config) + return rewriteValueMIPS64_OpAdd8(v) case OpAddPtr: - return rewriteValueMIPS64_OpAddPtr(v, config) + return rewriteValueMIPS64_OpAddPtr(v) case OpAddr: - return rewriteValueMIPS64_OpAddr(v, config) + return rewriteValueMIPS64_OpAddr(v) case OpAnd16: - return rewriteValueMIPS64_OpAnd16(v, config) + return rewriteValueMIPS64_OpAnd16(v) case OpAnd32: - return rewriteValueMIPS64_OpAnd32(v, config) + return rewriteValueMIPS64_OpAnd32(v) case OpAnd64: - return rewriteValueMIPS64_OpAnd64(v, config) + return rewriteValueMIPS64_OpAnd64(v) case OpAnd8: - return rewriteValueMIPS64_OpAnd8(v, config) + return rewriteValueMIPS64_OpAnd8(v) case OpAndB: - return rewriteValueMIPS64_OpAndB(v, config) + return rewriteValueMIPS64_OpAndB(v) case OpAvg64u: - return rewriteValueMIPS64_OpAvg64u(v, config) + return rewriteValueMIPS64_OpAvg64u(v) case OpClosureCall: - return rewriteValueMIPS64_OpClosureCall(v, config) + return rewriteValueMIPS64_OpClosureCall(v) case OpCom16: - return rewriteValueMIPS64_OpCom16(v, config) + return rewriteValueMIPS64_OpCom16(v) case OpCom32: - return rewriteValueMIPS64_OpCom32(v, config) + return rewriteValueMIPS64_OpCom32(v) case OpCom64: - return rewriteValueMIPS64_OpCom64(v, config) + return rewriteValueMIPS64_OpCom64(v) case OpCom8: - return rewriteValueMIPS64_OpCom8(v, config) + return rewriteValueMIPS64_OpCom8(v) case OpConst16: - return rewriteValueMIPS64_OpConst16(v, config) + return rewriteValueMIPS64_OpConst16(v) case OpConst32: - return rewriteValueMIPS64_OpConst32(v, config) + return rewriteValueMIPS64_OpConst32(v) case OpConst32F: - return rewriteValueMIPS64_OpConst32F(v, config) + return rewriteValueMIPS64_OpConst32F(v) case OpConst64: - return rewriteValueMIPS64_OpConst64(v, config) + return rewriteValueMIPS64_OpConst64(v) case OpConst64F: - return rewriteValueMIPS64_OpConst64F(v, config) + return rewriteValueMIPS64_OpConst64F(v) case OpConst8: - return rewriteValueMIPS64_OpConst8(v, config) + return rewriteValueMIPS64_OpConst8(v) case OpConstBool: - return rewriteValueMIPS64_OpConstBool(v, config) + return rewriteValueMIPS64_OpConstBool(v) case OpConstNil: - return rewriteValueMIPS64_OpConstNil(v, config) + return rewriteValueMIPS64_OpConstNil(v) case OpConvert: - return rewriteValueMIPS64_OpConvert(v, config) + return rewriteValueMIPS64_OpConvert(v) case OpCvt32Fto32: - return rewriteValueMIPS64_OpCvt32Fto32(v, config) + return rewriteValueMIPS64_OpCvt32Fto32(v) case OpCvt32Fto64: - return rewriteValueMIPS64_OpCvt32Fto64(v, config) + return rewriteValueMIPS64_OpCvt32Fto64(v) case OpCvt32Fto64F: - return rewriteValueMIPS64_OpCvt32Fto64F(v, config) + return rewriteValueMIPS64_OpCvt32Fto64F(v) case OpCvt32to32F: - return rewriteValueMIPS64_OpCvt32to32F(v, config) + return rewriteValueMIPS64_OpCvt32to32F(v) case OpCvt32to64F: - return rewriteValueMIPS64_OpCvt32to64F(v, config) + return rewriteValueMIPS64_OpCvt32to64F(v) case OpCvt64Fto32: - return rewriteValueMIPS64_OpCvt64Fto32(v, config) + return rewriteValueMIPS64_OpCvt64Fto32(v) case OpCvt64Fto32F: - return rewriteValueMIPS64_OpCvt64Fto32F(v, config) + return rewriteValueMIPS64_OpCvt64Fto32F(v) case OpCvt64Fto64: - return rewriteValueMIPS64_OpCvt64Fto64(v, config) + return rewriteValueMIPS64_OpCvt64Fto64(v) case OpCvt64to32F: - return rewriteValueMIPS64_OpCvt64to32F(v, config) + return rewriteValueMIPS64_OpCvt64to32F(v) case OpCvt64to64F: - return rewriteValueMIPS64_OpCvt64to64F(v, config) + return rewriteValueMIPS64_OpCvt64to64F(v) case OpDiv16: - return rewriteValueMIPS64_OpDiv16(v, config) + return rewriteValueMIPS64_OpDiv16(v) case OpDiv16u: - return rewriteValueMIPS64_OpDiv16u(v, config) + return rewriteValueMIPS64_OpDiv16u(v) case OpDiv32: - return rewriteValueMIPS64_OpDiv32(v, config) + return rewriteValueMIPS64_OpDiv32(v) case OpDiv32F: - return rewriteValueMIPS64_OpDiv32F(v, config) + return rewriteValueMIPS64_OpDiv32F(v) case OpDiv32u: - return rewriteValueMIPS64_OpDiv32u(v, config) + return rewriteValueMIPS64_OpDiv32u(v) case OpDiv64: - return rewriteValueMIPS64_OpDiv64(v, config) + return rewriteValueMIPS64_OpDiv64(v) case OpDiv64F: - return rewriteValueMIPS64_OpDiv64F(v, config) + return rewriteValueMIPS64_OpDiv64F(v) case OpDiv64u: - return rewriteValueMIPS64_OpDiv64u(v, config) + return rewriteValueMIPS64_OpDiv64u(v) case OpDiv8: - return rewriteValueMIPS64_OpDiv8(v, config) + return rewriteValueMIPS64_OpDiv8(v) case OpDiv8u: - return rewriteValueMIPS64_OpDiv8u(v, config) + return rewriteValueMIPS64_OpDiv8u(v) case OpEq16: - return rewriteValueMIPS64_OpEq16(v, config) + return rewriteValueMIPS64_OpEq16(v) case OpEq32: - return rewriteValueMIPS64_OpEq32(v, config) + return rewriteValueMIPS64_OpEq32(v) case OpEq32F: - return rewriteValueMIPS64_OpEq32F(v, config) + return rewriteValueMIPS64_OpEq32F(v) case OpEq64: - return rewriteValueMIPS64_OpEq64(v, config) + return rewriteValueMIPS64_OpEq64(v) case OpEq64F: - return rewriteValueMIPS64_OpEq64F(v, config) + return rewriteValueMIPS64_OpEq64F(v) case OpEq8: - return rewriteValueMIPS64_OpEq8(v, config) + return rewriteValueMIPS64_OpEq8(v) case OpEqB: - return rewriteValueMIPS64_OpEqB(v, config) + return rewriteValueMIPS64_OpEqB(v) case OpEqPtr: - return rewriteValueMIPS64_OpEqPtr(v, config) + return rewriteValueMIPS64_OpEqPtr(v) case OpGeq16: - return rewriteValueMIPS64_OpGeq16(v, config) + return rewriteValueMIPS64_OpGeq16(v) case OpGeq16U: - return rewriteValueMIPS64_OpGeq16U(v, config) + return rewriteValueMIPS64_OpGeq16U(v) case OpGeq32: - return rewriteValueMIPS64_OpGeq32(v, config) + return rewriteValueMIPS64_OpGeq32(v) case OpGeq32F: - return rewriteValueMIPS64_OpGeq32F(v, config) + return rewriteValueMIPS64_OpGeq32F(v) case OpGeq32U: - return rewriteValueMIPS64_OpGeq32U(v, config) + return rewriteValueMIPS64_OpGeq32U(v) case OpGeq64: - return rewriteValueMIPS64_OpGeq64(v, config) + return rewriteValueMIPS64_OpGeq64(v) case OpGeq64F: - return rewriteValueMIPS64_OpGeq64F(v, config) + return rewriteValueMIPS64_OpGeq64F(v) case OpGeq64U: - return rewriteValueMIPS64_OpGeq64U(v, config) + return rewriteValueMIPS64_OpGeq64U(v) case OpGeq8: - return rewriteValueMIPS64_OpGeq8(v, config) + return rewriteValueMIPS64_OpGeq8(v) case OpGeq8U: - return rewriteValueMIPS64_OpGeq8U(v, config) + return rewriteValueMIPS64_OpGeq8U(v) case OpGetClosurePtr: - return rewriteValueMIPS64_OpGetClosurePtr(v, config) + return rewriteValueMIPS64_OpGetClosurePtr(v) case OpGreater16: - return rewriteValueMIPS64_OpGreater16(v, config) + return rewriteValueMIPS64_OpGreater16(v) case OpGreater16U: - return rewriteValueMIPS64_OpGreater16U(v, config) + return rewriteValueMIPS64_OpGreater16U(v) case OpGreater32: - return rewriteValueMIPS64_OpGreater32(v, config) + return rewriteValueMIPS64_OpGreater32(v) case OpGreater32F: - return rewriteValueMIPS64_OpGreater32F(v, config) + return rewriteValueMIPS64_OpGreater32F(v) case OpGreater32U: - return rewriteValueMIPS64_OpGreater32U(v, config) + return rewriteValueMIPS64_OpGreater32U(v) case OpGreater64: - return rewriteValueMIPS64_OpGreater64(v, config) + return rewriteValueMIPS64_OpGreater64(v) case OpGreater64F: - return rewriteValueMIPS64_OpGreater64F(v, config) + return rewriteValueMIPS64_OpGreater64F(v) case OpGreater64U: - return rewriteValueMIPS64_OpGreater64U(v, config) + return rewriteValueMIPS64_OpGreater64U(v) case OpGreater8: - return rewriteValueMIPS64_OpGreater8(v, config) + return rewriteValueMIPS64_OpGreater8(v) case OpGreater8U: - return rewriteValueMIPS64_OpGreater8U(v, config) + return rewriteValueMIPS64_OpGreater8U(v) case OpHmul32: - return rewriteValueMIPS64_OpHmul32(v, config) + return rewriteValueMIPS64_OpHmul32(v) case OpHmul32u: - return rewriteValueMIPS64_OpHmul32u(v, config) + return rewriteValueMIPS64_OpHmul32u(v) case OpHmul64: - return rewriteValueMIPS64_OpHmul64(v, config) + return rewriteValueMIPS64_OpHmul64(v) case OpHmul64u: - return rewriteValueMIPS64_OpHmul64u(v, config) + return rewriteValueMIPS64_OpHmul64u(v) case OpInterCall: - return rewriteValueMIPS64_OpInterCall(v, config) + return rewriteValueMIPS64_OpInterCall(v) case OpIsInBounds: - return rewriteValueMIPS64_OpIsInBounds(v, config) + return rewriteValueMIPS64_OpIsInBounds(v) case OpIsNonNil: - return rewriteValueMIPS64_OpIsNonNil(v, config) + return rewriteValueMIPS64_OpIsNonNil(v) case OpIsSliceInBounds: - return rewriteValueMIPS64_OpIsSliceInBounds(v, config) + return rewriteValueMIPS64_OpIsSliceInBounds(v) case OpLeq16: - return rewriteValueMIPS64_OpLeq16(v, config) + return rewriteValueMIPS64_OpLeq16(v) case OpLeq16U: - return rewriteValueMIPS64_OpLeq16U(v, config) + return rewriteValueMIPS64_OpLeq16U(v) case OpLeq32: - return rewriteValueMIPS64_OpLeq32(v, config) + return rewriteValueMIPS64_OpLeq32(v) case OpLeq32F: - return rewriteValueMIPS64_OpLeq32F(v, config) + return rewriteValueMIPS64_OpLeq32F(v) case OpLeq32U: - return rewriteValueMIPS64_OpLeq32U(v, config) + return rewriteValueMIPS64_OpLeq32U(v) case OpLeq64: - return rewriteValueMIPS64_OpLeq64(v, config) + return rewriteValueMIPS64_OpLeq64(v) case OpLeq64F: - return rewriteValueMIPS64_OpLeq64F(v, config) + return rewriteValueMIPS64_OpLeq64F(v) case OpLeq64U: - return rewriteValueMIPS64_OpLeq64U(v, config) + return rewriteValueMIPS64_OpLeq64U(v) case OpLeq8: - return rewriteValueMIPS64_OpLeq8(v, config) + return rewriteValueMIPS64_OpLeq8(v) case OpLeq8U: - return rewriteValueMIPS64_OpLeq8U(v, config) + return rewriteValueMIPS64_OpLeq8U(v) case OpLess16: - return rewriteValueMIPS64_OpLess16(v, config) + return rewriteValueMIPS64_OpLess16(v) case OpLess16U: - return rewriteValueMIPS64_OpLess16U(v, config) + return rewriteValueMIPS64_OpLess16U(v) case OpLess32: - return rewriteValueMIPS64_OpLess32(v, config) + return rewriteValueMIPS64_OpLess32(v) case OpLess32F: - return rewriteValueMIPS64_OpLess32F(v, config) + return rewriteValueMIPS64_OpLess32F(v) case OpLess32U: - return rewriteValueMIPS64_OpLess32U(v, config) + return rewriteValueMIPS64_OpLess32U(v) case OpLess64: - return rewriteValueMIPS64_OpLess64(v, config) + return rewriteValueMIPS64_OpLess64(v) case OpLess64F: - return rewriteValueMIPS64_OpLess64F(v, config) + return rewriteValueMIPS64_OpLess64F(v) case OpLess64U: - return rewriteValueMIPS64_OpLess64U(v, config) + return rewriteValueMIPS64_OpLess64U(v) case OpLess8: - return rewriteValueMIPS64_OpLess8(v, config) + return rewriteValueMIPS64_OpLess8(v) case OpLess8U: - return rewriteValueMIPS64_OpLess8U(v, config) + return rewriteValueMIPS64_OpLess8U(v) case OpLoad: - return rewriteValueMIPS64_OpLoad(v, config) + return rewriteValueMIPS64_OpLoad(v) case OpLsh16x16: - return rewriteValueMIPS64_OpLsh16x16(v, config) + return rewriteValueMIPS64_OpLsh16x16(v) case OpLsh16x32: - return rewriteValueMIPS64_OpLsh16x32(v, config) + return rewriteValueMIPS64_OpLsh16x32(v) case OpLsh16x64: - return rewriteValueMIPS64_OpLsh16x64(v, config) + return rewriteValueMIPS64_OpLsh16x64(v) case OpLsh16x8: - return rewriteValueMIPS64_OpLsh16x8(v, config) + return rewriteValueMIPS64_OpLsh16x8(v) case OpLsh32x16: - return rewriteValueMIPS64_OpLsh32x16(v, config) + return rewriteValueMIPS64_OpLsh32x16(v) case OpLsh32x32: - return rewriteValueMIPS64_OpLsh32x32(v, config) + return rewriteValueMIPS64_OpLsh32x32(v) case OpLsh32x64: - return rewriteValueMIPS64_OpLsh32x64(v, config) + return rewriteValueMIPS64_OpLsh32x64(v) case OpLsh32x8: - return rewriteValueMIPS64_OpLsh32x8(v, config) + return rewriteValueMIPS64_OpLsh32x8(v) case OpLsh64x16: - return rewriteValueMIPS64_OpLsh64x16(v, config) + return rewriteValueMIPS64_OpLsh64x16(v) case OpLsh64x32: - return rewriteValueMIPS64_OpLsh64x32(v, config) + return rewriteValueMIPS64_OpLsh64x32(v) case OpLsh64x64: - return rewriteValueMIPS64_OpLsh64x64(v, config) + return rewriteValueMIPS64_OpLsh64x64(v) case OpLsh64x8: - return rewriteValueMIPS64_OpLsh64x8(v, config) + return rewriteValueMIPS64_OpLsh64x8(v) case OpLsh8x16: - return rewriteValueMIPS64_OpLsh8x16(v, config) + return rewriteValueMIPS64_OpLsh8x16(v) case OpLsh8x32: - return rewriteValueMIPS64_OpLsh8x32(v, config) + return rewriteValueMIPS64_OpLsh8x32(v) case OpLsh8x64: - return rewriteValueMIPS64_OpLsh8x64(v, config) + return rewriteValueMIPS64_OpLsh8x64(v) case OpLsh8x8: - return rewriteValueMIPS64_OpLsh8x8(v, config) + return rewriteValueMIPS64_OpLsh8x8(v) case OpMIPS64ADDV: - return rewriteValueMIPS64_OpMIPS64ADDV(v, config) + return rewriteValueMIPS64_OpMIPS64ADDV(v) case OpMIPS64ADDVconst: - return rewriteValueMIPS64_OpMIPS64ADDVconst(v, config) + return rewriteValueMIPS64_OpMIPS64ADDVconst(v) case OpMIPS64AND: - return rewriteValueMIPS64_OpMIPS64AND(v, config) + return rewriteValueMIPS64_OpMIPS64AND(v) case OpMIPS64ANDconst: - return rewriteValueMIPS64_OpMIPS64ANDconst(v, config) + return rewriteValueMIPS64_OpMIPS64ANDconst(v) case OpMIPS64MOVBUload: - return rewriteValueMIPS64_OpMIPS64MOVBUload(v, config) + return rewriteValueMIPS64_OpMIPS64MOVBUload(v) case OpMIPS64MOVBUreg: - return rewriteValueMIPS64_OpMIPS64MOVBUreg(v, config) + return rewriteValueMIPS64_OpMIPS64MOVBUreg(v) case OpMIPS64MOVBload: - return rewriteValueMIPS64_OpMIPS64MOVBload(v, config) + return rewriteValueMIPS64_OpMIPS64MOVBload(v) case OpMIPS64MOVBreg: - return rewriteValueMIPS64_OpMIPS64MOVBreg(v, config) + return rewriteValueMIPS64_OpMIPS64MOVBreg(v) case OpMIPS64MOVBstore: - return rewriteValueMIPS64_OpMIPS64MOVBstore(v, config) + return rewriteValueMIPS64_OpMIPS64MOVBstore(v) case OpMIPS64MOVBstorezero: - return rewriteValueMIPS64_OpMIPS64MOVBstorezero(v, config) + return rewriteValueMIPS64_OpMIPS64MOVBstorezero(v) case OpMIPS64MOVDload: - return rewriteValueMIPS64_OpMIPS64MOVDload(v, config) + return rewriteValueMIPS64_OpMIPS64MOVDload(v) case OpMIPS64MOVDstore: - return rewriteValueMIPS64_OpMIPS64MOVDstore(v, config) + return rewriteValueMIPS64_OpMIPS64MOVDstore(v) case OpMIPS64MOVFload: - return rewriteValueMIPS64_OpMIPS64MOVFload(v, config) + return rewriteValueMIPS64_OpMIPS64MOVFload(v) case OpMIPS64MOVFstore: - return rewriteValueMIPS64_OpMIPS64MOVFstore(v, config) + return rewriteValueMIPS64_OpMIPS64MOVFstore(v) case OpMIPS64MOVHUload: - return rewriteValueMIPS64_OpMIPS64MOVHUload(v, config) + return rewriteValueMIPS64_OpMIPS64MOVHUload(v) case OpMIPS64MOVHUreg: - return rewriteValueMIPS64_OpMIPS64MOVHUreg(v, config) + return rewriteValueMIPS64_OpMIPS64MOVHUreg(v) case OpMIPS64MOVHload: - return rewriteValueMIPS64_OpMIPS64MOVHload(v, config) + return rewriteValueMIPS64_OpMIPS64MOVHload(v) case OpMIPS64MOVHreg: - return rewriteValueMIPS64_OpMIPS64MOVHreg(v, config) + return rewriteValueMIPS64_OpMIPS64MOVHreg(v) case OpMIPS64MOVHstore: - return rewriteValueMIPS64_OpMIPS64MOVHstore(v, config) + return rewriteValueMIPS64_OpMIPS64MOVHstore(v) case OpMIPS64MOVHstorezero: - return rewriteValueMIPS64_OpMIPS64MOVHstorezero(v, config) + return rewriteValueMIPS64_OpMIPS64MOVHstorezero(v) case OpMIPS64MOVVload: - return rewriteValueMIPS64_OpMIPS64MOVVload(v, config) + return rewriteValueMIPS64_OpMIPS64MOVVload(v) case OpMIPS64MOVVreg: - return rewriteValueMIPS64_OpMIPS64MOVVreg(v, config) + return rewriteValueMIPS64_OpMIPS64MOVVreg(v) case OpMIPS64MOVVstore: - return rewriteValueMIPS64_OpMIPS64MOVVstore(v, config) + return rewriteValueMIPS64_OpMIPS64MOVVstore(v) case OpMIPS64MOVVstorezero: - return rewriteValueMIPS64_OpMIPS64MOVVstorezero(v, config) + return rewriteValueMIPS64_OpMIPS64MOVVstorezero(v) case OpMIPS64MOVWUload: - return rewriteValueMIPS64_OpMIPS64MOVWUload(v, config) + return rewriteValueMIPS64_OpMIPS64MOVWUload(v) case OpMIPS64MOVWUreg: - return rewriteValueMIPS64_OpMIPS64MOVWUreg(v, config) + return rewriteValueMIPS64_OpMIPS64MOVWUreg(v) case OpMIPS64MOVWload: - return rewriteValueMIPS64_OpMIPS64MOVWload(v, config) + return rewriteValueMIPS64_OpMIPS64MOVWload(v) case OpMIPS64MOVWreg: - return rewriteValueMIPS64_OpMIPS64MOVWreg(v, config) + return rewriteValueMIPS64_OpMIPS64MOVWreg(v) case OpMIPS64MOVWstore: - return rewriteValueMIPS64_OpMIPS64MOVWstore(v, config) + return rewriteValueMIPS64_OpMIPS64MOVWstore(v) case OpMIPS64MOVWstorezero: - return rewriteValueMIPS64_OpMIPS64MOVWstorezero(v, config) + return rewriteValueMIPS64_OpMIPS64MOVWstorezero(v) case OpMIPS64NEGV: - return rewriteValueMIPS64_OpMIPS64NEGV(v, config) + return rewriteValueMIPS64_OpMIPS64NEGV(v) case OpMIPS64NOR: - return rewriteValueMIPS64_OpMIPS64NOR(v, config) + return rewriteValueMIPS64_OpMIPS64NOR(v) case OpMIPS64NORconst: - return rewriteValueMIPS64_OpMIPS64NORconst(v, config) + return rewriteValueMIPS64_OpMIPS64NORconst(v) case OpMIPS64OR: - return rewriteValueMIPS64_OpMIPS64OR(v, config) + return rewriteValueMIPS64_OpMIPS64OR(v) case OpMIPS64ORconst: - return rewriteValueMIPS64_OpMIPS64ORconst(v, config) + return rewriteValueMIPS64_OpMIPS64ORconst(v) case OpMIPS64SGT: - return rewriteValueMIPS64_OpMIPS64SGT(v, config) + return rewriteValueMIPS64_OpMIPS64SGT(v) case OpMIPS64SGTU: - return rewriteValueMIPS64_OpMIPS64SGTU(v, config) + return rewriteValueMIPS64_OpMIPS64SGTU(v) case OpMIPS64SGTUconst: - return rewriteValueMIPS64_OpMIPS64SGTUconst(v, config) + return rewriteValueMIPS64_OpMIPS64SGTUconst(v) case OpMIPS64SGTconst: - return rewriteValueMIPS64_OpMIPS64SGTconst(v, config) + return rewriteValueMIPS64_OpMIPS64SGTconst(v) case OpMIPS64SLLV: - return rewriteValueMIPS64_OpMIPS64SLLV(v, config) + return rewriteValueMIPS64_OpMIPS64SLLV(v) case OpMIPS64SLLVconst: - return rewriteValueMIPS64_OpMIPS64SLLVconst(v, config) + return rewriteValueMIPS64_OpMIPS64SLLVconst(v) case OpMIPS64SRAV: - return rewriteValueMIPS64_OpMIPS64SRAV(v, config) + return rewriteValueMIPS64_OpMIPS64SRAV(v) case OpMIPS64SRAVconst: - return rewriteValueMIPS64_OpMIPS64SRAVconst(v, config) + return rewriteValueMIPS64_OpMIPS64SRAVconst(v) case OpMIPS64SRLV: - return rewriteValueMIPS64_OpMIPS64SRLV(v, config) + return rewriteValueMIPS64_OpMIPS64SRLV(v) case OpMIPS64SRLVconst: - return rewriteValueMIPS64_OpMIPS64SRLVconst(v, config) + return rewriteValueMIPS64_OpMIPS64SRLVconst(v) case OpMIPS64SUBV: - return rewriteValueMIPS64_OpMIPS64SUBV(v, config) + return rewriteValueMIPS64_OpMIPS64SUBV(v) case OpMIPS64SUBVconst: - return rewriteValueMIPS64_OpMIPS64SUBVconst(v, config) + return rewriteValueMIPS64_OpMIPS64SUBVconst(v) case OpMIPS64XOR: - return rewriteValueMIPS64_OpMIPS64XOR(v, config) + return rewriteValueMIPS64_OpMIPS64XOR(v) case OpMIPS64XORconst: - return rewriteValueMIPS64_OpMIPS64XORconst(v, config) + return rewriteValueMIPS64_OpMIPS64XORconst(v) case OpMod16: - return rewriteValueMIPS64_OpMod16(v, config) + return rewriteValueMIPS64_OpMod16(v) case OpMod16u: - return rewriteValueMIPS64_OpMod16u(v, config) + return rewriteValueMIPS64_OpMod16u(v) case OpMod32: - return rewriteValueMIPS64_OpMod32(v, config) + return rewriteValueMIPS64_OpMod32(v) case OpMod32u: - return rewriteValueMIPS64_OpMod32u(v, config) + return rewriteValueMIPS64_OpMod32u(v) case OpMod64: - return rewriteValueMIPS64_OpMod64(v, config) + return rewriteValueMIPS64_OpMod64(v) case OpMod64u: - return rewriteValueMIPS64_OpMod64u(v, config) + return rewriteValueMIPS64_OpMod64u(v) case OpMod8: - return rewriteValueMIPS64_OpMod8(v, config) + return rewriteValueMIPS64_OpMod8(v) case OpMod8u: - return rewriteValueMIPS64_OpMod8u(v, config) + return rewriteValueMIPS64_OpMod8u(v) case OpMove: - return rewriteValueMIPS64_OpMove(v, config) + return rewriteValueMIPS64_OpMove(v) case OpMul16: - return rewriteValueMIPS64_OpMul16(v, config) + return rewriteValueMIPS64_OpMul16(v) case OpMul32: - return rewriteValueMIPS64_OpMul32(v, config) + return rewriteValueMIPS64_OpMul32(v) case OpMul32F: - return rewriteValueMIPS64_OpMul32F(v, config) + return rewriteValueMIPS64_OpMul32F(v) case OpMul64: - return rewriteValueMIPS64_OpMul64(v, config) + return rewriteValueMIPS64_OpMul64(v) case OpMul64F: - return rewriteValueMIPS64_OpMul64F(v, config) + return rewriteValueMIPS64_OpMul64F(v) case OpMul8: - return rewriteValueMIPS64_OpMul8(v, config) + return rewriteValueMIPS64_OpMul8(v) case OpNeg16: - return rewriteValueMIPS64_OpNeg16(v, config) + return rewriteValueMIPS64_OpNeg16(v) case OpNeg32: - return rewriteValueMIPS64_OpNeg32(v, config) + return rewriteValueMIPS64_OpNeg32(v) case OpNeg32F: - return rewriteValueMIPS64_OpNeg32F(v, config) + return rewriteValueMIPS64_OpNeg32F(v) case OpNeg64: - return rewriteValueMIPS64_OpNeg64(v, config) + return rewriteValueMIPS64_OpNeg64(v) case OpNeg64F: - return rewriteValueMIPS64_OpNeg64F(v, config) + return rewriteValueMIPS64_OpNeg64F(v) case OpNeg8: - return rewriteValueMIPS64_OpNeg8(v, config) + return rewriteValueMIPS64_OpNeg8(v) case OpNeq16: - return rewriteValueMIPS64_OpNeq16(v, config) + return rewriteValueMIPS64_OpNeq16(v) case OpNeq32: - return rewriteValueMIPS64_OpNeq32(v, config) + return rewriteValueMIPS64_OpNeq32(v) case OpNeq32F: - return rewriteValueMIPS64_OpNeq32F(v, config) + return rewriteValueMIPS64_OpNeq32F(v) case OpNeq64: - return rewriteValueMIPS64_OpNeq64(v, config) + return rewriteValueMIPS64_OpNeq64(v) case OpNeq64F: - return rewriteValueMIPS64_OpNeq64F(v, config) + return rewriteValueMIPS64_OpNeq64F(v) case OpNeq8: - return rewriteValueMIPS64_OpNeq8(v, config) + return rewriteValueMIPS64_OpNeq8(v) case OpNeqB: - return rewriteValueMIPS64_OpNeqB(v, config) + return rewriteValueMIPS64_OpNeqB(v) case OpNeqPtr: - return rewriteValueMIPS64_OpNeqPtr(v, config) + return rewriteValueMIPS64_OpNeqPtr(v) case OpNilCheck: - return rewriteValueMIPS64_OpNilCheck(v, config) + return rewriteValueMIPS64_OpNilCheck(v) case OpNot: - return rewriteValueMIPS64_OpNot(v, config) + return rewriteValueMIPS64_OpNot(v) case OpOffPtr: - return rewriteValueMIPS64_OpOffPtr(v, config) + return rewriteValueMIPS64_OpOffPtr(v) case OpOr16: - return rewriteValueMIPS64_OpOr16(v, config) + return rewriteValueMIPS64_OpOr16(v) case OpOr32: - return rewriteValueMIPS64_OpOr32(v, config) + return rewriteValueMIPS64_OpOr32(v) case OpOr64: - return rewriteValueMIPS64_OpOr64(v, config) + return rewriteValueMIPS64_OpOr64(v) case OpOr8: - return rewriteValueMIPS64_OpOr8(v, config) + return rewriteValueMIPS64_OpOr8(v) case OpOrB: - return rewriteValueMIPS64_OpOrB(v, config) + return rewriteValueMIPS64_OpOrB(v) case OpRound32F: - return rewriteValueMIPS64_OpRound32F(v, config) + return rewriteValueMIPS64_OpRound32F(v) case OpRound64F: - return rewriteValueMIPS64_OpRound64F(v, config) + return rewriteValueMIPS64_OpRound64F(v) case OpRsh16Ux16: - return rewriteValueMIPS64_OpRsh16Ux16(v, config) + return rewriteValueMIPS64_OpRsh16Ux16(v) case OpRsh16Ux32: - return rewriteValueMIPS64_OpRsh16Ux32(v, config) + return rewriteValueMIPS64_OpRsh16Ux32(v) case OpRsh16Ux64: - return rewriteValueMIPS64_OpRsh16Ux64(v, config) + return rewriteValueMIPS64_OpRsh16Ux64(v) case OpRsh16Ux8: - return rewriteValueMIPS64_OpRsh16Ux8(v, config) + return rewriteValueMIPS64_OpRsh16Ux8(v) case OpRsh16x16: - return rewriteValueMIPS64_OpRsh16x16(v, config) + return rewriteValueMIPS64_OpRsh16x16(v) case OpRsh16x32: - return rewriteValueMIPS64_OpRsh16x32(v, config) + return rewriteValueMIPS64_OpRsh16x32(v) case OpRsh16x64: - return rewriteValueMIPS64_OpRsh16x64(v, config) + return rewriteValueMIPS64_OpRsh16x64(v) case OpRsh16x8: - return rewriteValueMIPS64_OpRsh16x8(v, config) + return rewriteValueMIPS64_OpRsh16x8(v) case OpRsh32Ux16: - return rewriteValueMIPS64_OpRsh32Ux16(v, config) + return rewriteValueMIPS64_OpRsh32Ux16(v) case OpRsh32Ux32: - return rewriteValueMIPS64_OpRsh32Ux32(v, config) + return rewriteValueMIPS64_OpRsh32Ux32(v) case OpRsh32Ux64: - return rewriteValueMIPS64_OpRsh32Ux64(v, config) + return rewriteValueMIPS64_OpRsh32Ux64(v) case OpRsh32Ux8: - return rewriteValueMIPS64_OpRsh32Ux8(v, config) + return rewriteValueMIPS64_OpRsh32Ux8(v) case OpRsh32x16: - return rewriteValueMIPS64_OpRsh32x16(v, config) + return rewriteValueMIPS64_OpRsh32x16(v) case OpRsh32x32: - return rewriteValueMIPS64_OpRsh32x32(v, config) + return rewriteValueMIPS64_OpRsh32x32(v) case OpRsh32x64: - return rewriteValueMIPS64_OpRsh32x64(v, config) + return rewriteValueMIPS64_OpRsh32x64(v) case OpRsh32x8: - return rewriteValueMIPS64_OpRsh32x8(v, config) + return rewriteValueMIPS64_OpRsh32x8(v) case OpRsh64Ux16: - return rewriteValueMIPS64_OpRsh64Ux16(v, config) + return rewriteValueMIPS64_OpRsh64Ux16(v) case OpRsh64Ux32: - return rewriteValueMIPS64_OpRsh64Ux32(v, config) + return rewriteValueMIPS64_OpRsh64Ux32(v) case OpRsh64Ux64: - return rewriteValueMIPS64_OpRsh64Ux64(v, config) + return rewriteValueMIPS64_OpRsh64Ux64(v) case OpRsh64Ux8: - return rewriteValueMIPS64_OpRsh64Ux8(v, config) + return rewriteValueMIPS64_OpRsh64Ux8(v) case OpRsh64x16: - return rewriteValueMIPS64_OpRsh64x16(v, config) + return rewriteValueMIPS64_OpRsh64x16(v) case OpRsh64x32: - return rewriteValueMIPS64_OpRsh64x32(v, config) + return rewriteValueMIPS64_OpRsh64x32(v) case OpRsh64x64: - return rewriteValueMIPS64_OpRsh64x64(v, config) + return rewriteValueMIPS64_OpRsh64x64(v) case OpRsh64x8: - return rewriteValueMIPS64_OpRsh64x8(v, config) + return rewriteValueMIPS64_OpRsh64x8(v) case OpRsh8Ux16: - return rewriteValueMIPS64_OpRsh8Ux16(v, config) + return rewriteValueMIPS64_OpRsh8Ux16(v) case OpRsh8Ux32: - return rewriteValueMIPS64_OpRsh8Ux32(v, config) + return rewriteValueMIPS64_OpRsh8Ux32(v) case OpRsh8Ux64: - return rewriteValueMIPS64_OpRsh8Ux64(v, config) + return rewriteValueMIPS64_OpRsh8Ux64(v) case OpRsh8Ux8: - return rewriteValueMIPS64_OpRsh8Ux8(v, config) + return rewriteValueMIPS64_OpRsh8Ux8(v) case OpRsh8x16: - return rewriteValueMIPS64_OpRsh8x16(v, config) + return rewriteValueMIPS64_OpRsh8x16(v) case OpRsh8x32: - return rewriteValueMIPS64_OpRsh8x32(v, config) + return rewriteValueMIPS64_OpRsh8x32(v) case OpRsh8x64: - return rewriteValueMIPS64_OpRsh8x64(v, config) + return rewriteValueMIPS64_OpRsh8x64(v) case OpRsh8x8: - return rewriteValueMIPS64_OpRsh8x8(v, config) + return rewriteValueMIPS64_OpRsh8x8(v) case OpSelect0: - return rewriteValueMIPS64_OpSelect0(v, config) + return rewriteValueMIPS64_OpSelect0(v) case OpSelect1: - return rewriteValueMIPS64_OpSelect1(v, config) + return rewriteValueMIPS64_OpSelect1(v) case OpSignExt16to32: - return rewriteValueMIPS64_OpSignExt16to32(v, config) + return rewriteValueMIPS64_OpSignExt16to32(v) case OpSignExt16to64: - return rewriteValueMIPS64_OpSignExt16to64(v, config) + return rewriteValueMIPS64_OpSignExt16to64(v) case OpSignExt32to64: - return rewriteValueMIPS64_OpSignExt32to64(v, config) + return rewriteValueMIPS64_OpSignExt32to64(v) case OpSignExt8to16: - return rewriteValueMIPS64_OpSignExt8to16(v, config) + return rewriteValueMIPS64_OpSignExt8to16(v) case OpSignExt8to32: - return rewriteValueMIPS64_OpSignExt8to32(v, config) + return rewriteValueMIPS64_OpSignExt8to32(v) case OpSignExt8to64: - return rewriteValueMIPS64_OpSignExt8to64(v, config) + return rewriteValueMIPS64_OpSignExt8to64(v) case OpSlicemask: - return rewriteValueMIPS64_OpSlicemask(v, config) + return rewriteValueMIPS64_OpSlicemask(v) case OpStaticCall: - return rewriteValueMIPS64_OpStaticCall(v, config) + return rewriteValueMIPS64_OpStaticCall(v) case OpStore: - return rewriteValueMIPS64_OpStore(v, config) + return rewriteValueMIPS64_OpStore(v) case OpSub16: - return rewriteValueMIPS64_OpSub16(v, config) + return rewriteValueMIPS64_OpSub16(v) case OpSub32: - return rewriteValueMIPS64_OpSub32(v, config) + return rewriteValueMIPS64_OpSub32(v) case OpSub32F: - return rewriteValueMIPS64_OpSub32F(v, config) + return rewriteValueMIPS64_OpSub32F(v) case OpSub64: - return rewriteValueMIPS64_OpSub64(v, config) + return rewriteValueMIPS64_OpSub64(v) case OpSub64F: - return rewriteValueMIPS64_OpSub64F(v, config) + return rewriteValueMIPS64_OpSub64F(v) case OpSub8: - return rewriteValueMIPS64_OpSub8(v, config) + return rewriteValueMIPS64_OpSub8(v) case OpSubPtr: - return rewriteValueMIPS64_OpSubPtr(v, config) + return rewriteValueMIPS64_OpSubPtr(v) case OpTrunc16to8: - return rewriteValueMIPS64_OpTrunc16to8(v, config) + return rewriteValueMIPS64_OpTrunc16to8(v) case OpTrunc32to16: - return rewriteValueMIPS64_OpTrunc32to16(v, config) + return rewriteValueMIPS64_OpTrunc32to16(v) case OpTrunc32to8: - return rewriteValueMIPS64_OpTrunc32to8(v, config) + return rewriteValueMIPS64_OpTrunc32to8(v) case OpTrunc64to16: - return rewriteValueMIPS64_OpTrunc64to16(v, config) + return rewriteValueMIPS64_OpTrunc64to16(v) case OpTrunc64to32: - return rewriteValueMIPS64_OpTrunc64to32(v, config) + return rewriteValueMIPS64_OpTrunc64to32(v) case OpTrunc64to8: - return rewriteValueMIPS64_OpTrunc64to8(v, config) + return rewriteValueMIPS64_OpTrunc64to8(v) case OpXor16: - return rewriteValueMIPS64_OpXor16(v, config) + return rewriteValueMIPS64_OpXor16(v) case OpXor32: - return rewriteValueMIPS64_OpXor32(v, config) + return rewriteValueMIPS64_OpXor32(v) case OpXor64: - return rewriteValueMIPS64_OpXor64(v, config) + return rewriteValueMIPS64_OpXor64(v) case OpXor8: - return rewriteValueMIPS64_OpXor8(v, config) + return rewriteValueMIPS64_OpXor8(v) case OpZero: - return rewriteValueMIPS64_OpZero(v, config) + return rewriteValueMIPS64_OpZero(v) case OpZeroExt16to32: - return rewriteValueMIPS64_OpZeroExt16to32(v, config) + return rewriteValueMIPS64_OpZeroExt16to32(v) case OpZeroExt16to64: - return rewriteValueMIPS64_OpZeroExt16to64(v, config) + return rewriteValueMIPS64_OpZeroExt16to64(v) case OpZeroExt32to64: - return rewriteValueMIPS64_OpZeroExt32to64(v, config) + return rewriteValueMIPS64_OpZeroExt32to64(v) case OpZeroExt8to16: - return rewriteValueMIPS64_OpZeroExt8to16(v, config) + return rewriteValueMIPS64_OpZeroExt8to16(v) case OpZeroExt8to32: - return rewriteValueMIPS64_OpZeroExt8to32(v, config) + return rewriteValueMIPS64_OpZeroExt8to32(v) case OpZeroExt8to64: - return rewriteValueMIPS64_OpZeroExt8to64(v, config) + return rewriteValueMIPS64_OpZeroExt8to64(v) } return false } -func rewriteValueMIPS64_OpAdd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAdd16(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADDV x y) @@ -580,9 +578,7 @@ func rewriteValueMIPS64_OpAdd16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAdd32(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADDV x y) @@ -595,9 +591,7 @@ func rewriteValueMIPS64_OpAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAdd32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAdd32F(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDF x y) @@ -610,9 +604,7 @@ func rewriteValueMIPS64_OpAdd32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAdd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAdd64(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADDV x y) @@ -625,9 +617,7 @@ func rewriteValueMIPS64_OpAdd64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAdd64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAdd64F(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDD x y) @@ -640,9 +630,7 @@ func rewriteValueMIPS64_OpAdd64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAdd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAdd8(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADDV x y) @@ -655,9 +643,7 @@ func rewriteValueMIPS64_OpAdd8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAddPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAddPtr(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADDV x y) @@ -670,9 +656,7 @@ func rewriteValueMIPS64_OpAddPtr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAddr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAddr(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVVaddr {sym} base) @@ -685,9 +669,7 @@ func rewriteValueMIPS64_OpAddr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAnd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAnd16(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -700,9 +682,7 @@ func rewriteValueMIPS64_OpAnd16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAnd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAnd32(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -715,9 +695,7 @@ func rewriteValueMIPS64_OpAnd32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAnd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAnd64(v *Value) bool { // match: (And64 x y) // cond: // result: (AND x y) @@ -730,9 +708,7 @@ func rewriteValueMIPS64_OpAnd64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAnd8(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -745,9 +721,7 @@ func rewriteValueMIPS64_OpAnd8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAndB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpAndB(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -760,7 +734,7 @@ func rewriteValueMIPS64_OpAndB(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpAvg64u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpAvg64u(v *Value) bool { b := v.Block _ = b // match: (Avg64u <t> x y) @@ -782,9 +756,7 @@ func rewriteValueMIPS64_OpAvg64u(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpClosureCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpClosureCall(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -801,73 +773,87 @@ func rewriteValueMIPS64_OpClosureCall(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCom16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpCom16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Com16 x) // cond: // result: (NOR (MOVVconst [0]) x) for { x := v.Args[0] v.reset(OpMIPS64NOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(x) return true } } -func rewriteValueMIPS64_OpCom32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpCom32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Com32 x) // cond: // result: (NOR (MOVVconst [0]) x) for { x := v.Args[0] v.reset(OpMIPS64NOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(x) return true } } -func rewriteValueMIPS64_OpCom64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpCom64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Com64 x) // cond: // result: (NOR (MOVVconst [0]) x) for { x := v.Args[0] v.reset(OpMIPS64NOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(x) return true } } -func rewriteValueMIPS64_OpCom8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpCom8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Com8 x) // cond: // result: (NOR (MOVVconst [0]) x) for { x := v.Args[0] v.reset(OpMIPS64NOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(x) return true } } -func rewriteValueMIPS64_OpConst16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpConst16(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVVconst [val]) @@ -878,9 +864,7 @@ func rewriteValueMIPS64_OpConst16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpConst32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpConst32(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVVconst [val]) @@ -891,9 +875,7 @@ func rewriteValueMIPS64_OpConst32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpConst32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpConst32F(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVFconst [val]) @@ -904,9 +886,7 @@ func rewriteValueMIPS64_OpConst32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpConst64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpConst64(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVVconst [val]) @@ -917,9 +897,7 @@ func rewriteValueMIPS64_OpConst64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpConst64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpConst64F(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVDconst [val]) @@ -930,9 +908,7 @@ func rewriteValueMIPS64_OpConst64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpConst8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpConst8(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVVconst [val]) @@ -943,9 +919,7 @@ func rewriteValueMIPS64_OpConst8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpConstBool(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpConstBool(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVVconst [b]) @@ -956,9 +930,7 @@ func rewriteValueMIPS64_OpConstBool(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpConstNil(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpConstNil(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVVconst [0]) @@ -968,9 +940,7 @@ func rewriteValueMIPS64_OpConstNil(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpConvert(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpConvert(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVVconvert x mem) @@ -983,9 +953,7 @@ func rewriteValueMIPS64_OpConvert(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt32Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt32Fto32(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (TRUNCFW x) @@ -996,9 +964,7 @@ func rewriteValueMIPS64_OpCvt32Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt32Fto64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt32Fto64(v *Value) bool { // match: (Cvt32Fto64 x) // cond: // result: (TRUNCFV x) @@ -1009,9 +975,7 @@ func rewriteValueMIPS64_OpCvt32Fto64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt32Fto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt32Fto64F(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (MOVFD x) @@ -1022,9 +986,7 @@ func rewriteValueMIPS64_OpCvt32Fto64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt32to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt32to32F(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (MOVWF x) @@ -1035,9 +997,7 @@ func rewriteValueMIPS64_OpCvt32to32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt32to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt32to64F(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (MOVWD x) @@ -1048,9 +1008,7 @@ func rewriteValueMIPS64_OpCvt32to64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt64Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt64Fto32(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (TRUNCDW x) @@ -1061,9 +1019,7 @@ func rewriteValueMIPS64_OpCvt64Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt64Fto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt64Fto32F(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (MOVDF x) @@ -1074,9 +1030,7 @@ func rewriteValueMIPS64_OpCvt64Fto32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt64Fto64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt64Fto64(v *Value) bool { // match: (Cvt64Fto64 x) // cond: // result: (TRUNCDV x) @@ -1087,9 +1041,7 @@ func rewriteValueMIPS64_OpCvt64Fto64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt64to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt64to32F(v *Value) bool { // match: (Cvt64to32F x) // cond: // result: (MOVVF x) @@ -1100,9 +1052,7 @@ func rewriteValueMIPS64_OpCvt64to32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpCvt64to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpCvt64to64F(v *Value) bool { // match: (Cvt64to64F x) // cond: // result: (MOVVD x) @@ -1113,9 +1063,13 @@ func rewriteValueMIPS64_OpCvt64to64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpDiv16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpDiv16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16 x y) // cond: // result: (Select1 (DIVV (SignExt16to64 x) (SignExt16to64 y))) @@ -1123,20 +1077,24 @@ func rewriteValueMIPS64_OpDiv16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) - v1 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) + v1 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpDiv16u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpDiv16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16u x y) // cond: // result: (Select1 (DIVVU (ZeroExt16to64 x) (ZeroExt16to64 y))) @@ -1144,20 +1102,24 @@ func rewriteValueMIPS64_OpDiv16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpDiv32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpDiv32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32 x y) // cond: // result: (Select1 (DIVV (SignExt32to64 x) (SignExt32to64 y))) @@ -1165,20 +1127,18 @@ func rewriteValueMIPS64_OpDiv32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) - v1 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) + v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpDiv32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpDiv32F(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVF x y) @@ -1191,9 +1151,13 @@ func rewriteValueMIPS64_OpDiv32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpDiv32u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpDiv32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32u x y) // cond: // result: (Select1 (DIVVU (ZeroExt32to64 x) (ZeroExt32to64 y))) @@ -1201,20 +1165,24 @@ func rewriteValueMIPS64_OpDiv32u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpDiv64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpDiv64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div64 x y) // cond: // result: (Select1 (DIVV x y)) @@ -1222,16 +1190,14 @@ func rewriteValueMIPS64_OpDiv64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpDiv64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpDiv64F(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVD x y) @@ -1244,9 +1210,13 @@ func rewriteValueMIPS64_OpDiv64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpDiv64u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpDiv64u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div64u x y) // cond: // result: (Select1 (DIVVU x y)) @@ -1254,16 +1224,20 @@ func rewriteValueMIPS64_OpDiv64u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpDiv8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpDiv8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8 x y) // cond: // result: (Select1 (DIVV (SignExt8to64 x) (SignExt8to64 y))) @@ -1271,20 +1245,24 @@ func rewriteValueMIPS64_OpDiv8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) - v1 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) + v1 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpDiv8u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpDiv8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8u x y) // cond: // result: (Select1 (DIVVU (ZeroExt8to64 x) (ZeroExt8to64 y))) @@ -1292,20 +1270,24 @@ func rewriteValueMIPS64_OpDiv8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpEq16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpEq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq16 x y) // cond: // result: (SGTU (MOVVconst [1]) (XOR (ZeroExt16to64 x) (ZeroExt16to64 y))) @@ -1313,23 +1295,27 @@ func rewriteValueMIPS64_OpEq16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpEq32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpEq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq32 x y) // cond: // result: (SGTU (MOVVconst [1]) (XOR (ZeroExt32to64 x) (ZeroExt32to64 y))) @@ -1337,21 +1323,21 @@ func rewriteValueMIPS64_OpEq32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpEq32F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpEq32F(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -1368,9 +1354,13 @@ func rewriteValueMIPS64_OpEq32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpEq64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpEq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq64 x y) // cond: // result: (SGTU (MOVVconst [1]) (XOR x y)) @@ -1378,17 +1368,17 @@ func rewriteValueMIPS64_OpEq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) v1.AddArg(x) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpEq64F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpEq64F(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -1405,9 +1395,13 @@ func rewriteValueMIPS64_OpEq64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpEq8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpEq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq8 x y) // cond: // result: (SGTU (MOVVconst [1]) (XOR (ZeroExt8to64 x) (ZeroExt8to64 y))) @@ -1415,43 +1409,51 @@ func rewriteValueMIPS64_OpEq8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpEqB(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpEqB(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqB x y) // cond: - // result: (XOR (MOVVconst [1]) (XOR <config.fe.TypeBool()> x y)) + // result: (XOR (MOVVconst [1]) (XOR <fe.TypeBool()> x y)) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeBool()) v1.AddArg(x) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpEqPtr(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpEqPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqPtr x y) // cond: // result: (SGTU (MOVVconst [1]) (XOR x y)) @@ -1459,19 +1461,23 @@ func rewriteValueMIPS64_OpEqPtr(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) v1.AddArg(x) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGeq16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16 x y) // cond: // result: (XOR (MOVVconst [1]) (SGT (SignExt16to64 y) (SignExt16to64 x))) @@ -1479,23 +1485,27 @@ func rewriteValueMIPS64_OpGeq16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGT, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v3.AddArg(x) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGeq16U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16U x y) // cond: // result: (XOR (MOVVconst [1]) (SGTU (ZeroExt16to64 y) (ZeroExt16to64 x))) @@ -1503,23 +1513,27 @@ func rewriteValueMIPS64_OpGeq16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(x) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGeq32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq32 x y) // cond: // result: (XOR (MOVVconst [1]) (SGT (SignExt32to64 y) (SignExt32to64 x))) @@ -1527,21 +1541,21 @@ func rewriteValueMIPS64_OpGeq32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGT, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v3.AddArg(x) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGeq32F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq32F(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -1558,9 +1572,13 @@ func rewriteValueMIPS64_OpGeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpGeq32U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq32U x y) // cond: // result: (XOR (MOVVconst [1]) (SGTU (ZeroExt32to64 y) (ZeroExt32to64 x))) @@ -1568,23 +1586,27 @@ func rewriteValueMIPS64_OpGeq32U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(x) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGeq64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq64 x y) // cond: // result: (XOR (MOVVconst [1]) (SGT y x)) @@ -1592,17 +1614,17 @@ func rewriteValueMIPS64_OpGeq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGT, config.fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool()) v1.AddArg(y) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGeq64F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq64F(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -1619,9 +1641,13 @@ func rewriteValueMIPS64_OpGeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpGeq64U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq64U x y) // cond: // result: (XOR (MOVVconst [1]) (SGTU y x)) @@ -1629,19 +1655,23 @@ func rewriteValueMIPS64_OpGeq64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) v1.AddArg(y) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGeq8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8 x y) // cond: // result: (XOR (MOVVconst [1]) (SGT (SignExt8to64 y) (SignExt8to64 x))) @@ -1649,23 +1679,27 @@ func rewriteValueMIPS64_OpGeq8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGT, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v3.AddArg(x) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGeq8U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8U x y) // cond: // result: (XOR (MOVVconst [1]) (SGTU (ZeroExt8to64 y) (ZeroExt8to64 x))) @@ -1673,23 +1707,21 @@ func rewriteValueMIPS64_OpGeq8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(x) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGetClosurePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -1698,9 +1730,13 @@ func rewriteValueMIPS64_OpGetClosurePtr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpGreater16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGreater16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16 x y) // cond: // result: (SGT (SignExt16to64 x) (SignExt16to64 y)) @@ -1708,18 +1744,22 @@ func rewriteValueMIPS64_OpGreater16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGT) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGreater16U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGreater16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16U x y) // cond: // result: (SGTU (ZeroExt16to64 x) (ZeroExt16to64 y)) @@ -1727,18 +1767,22 @@ func rewriteValueMIPS64_OpGreater16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGreater32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGreater32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater32 x y) // cond: // result: (SGT (SignExt32to64 x) (SignExt32to64 y)) @@ -1746,16 +1790,16 @@ func rewriteValueMIPS64_OpGreater32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGT) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGreater32F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGreater32F(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -1772,9 +1816,13 @@ func rewriteValueMIPS64_OpGreater32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpGreater32U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGreater32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater32U x y) // cond: // result: (SGTU (ZeroExt32to64 x) (ZeroExt32to64 y)) @@ -1782,18 +1830,16 @@ func rewriteValueMIPS64_OpGreater32U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGreater64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpGreater64(v *Value) bool { // match: (Greater64 x y) // cond: // result: (SGT x y) @@ -1806,7 +1852,7 @@ func rewriteValueMIPS64_OpGreater64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpGreater64F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGreater64F(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -1823,9 +1869,7 @@ func rewriteValueMIPS64_OpGreater64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpGreater64U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpGreater64U(v *Value) bool { // match: (Greater64U x y) // cond: // result: (SGTU x y) @@ -1838,9 +1882,13 @@ func rewriteValueMIPS64_OpGreater64U(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpGreater8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGreater8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8 x y) // cond: // result: (SGT (SignExt8to64 x) (SignExt8to64 y)) @@ -1848,18 +1896,22 @@ func rewriteValueMIPS64_OpGreater8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGT) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpGreater8U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpGreater8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8U x y) // cond: // result: (SGTU (ZeroExt8to64 x) (ZeroExt8to64 y)) @@ -1867,32 +1919,36 @@ func rewriteValueMIPS64_OpGreater8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpHmul32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpHmul32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul32 x y) // cond: - // result: (SRAVconst (Select1 <config.fe.TypeInt64()> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32]) + // result: (SRAVconst (Select1 <fe.TypeInt64()> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32]) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAVconst) v.AuxInt = 32 - v0 := b.NewValue0(v.Pos, OpSelect1, config.fe.TypeInt64()) - v1 := b.NewValue0(v.Pos, OpMIPS64MULV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) - v2 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSelect1, fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64MULV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) + v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) @@ -1900,23 +1956,27 @@ func rewriteValueMIPS64_OpHmul32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpHmul32u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpHmul32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul32u x y) // cond: - // result: (SRLVconst (Select1 <config.fe.TypeUInt64()> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32]) + // result: (SRLVconst (Select1 <fe.TypeUInt64()> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32]) for { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRLVconst) v.AuxInt = 32 - v0 := b.NewValue0(v.Pos, OpSelect1, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpSelect1, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) @@ -1924,9 +1984,13 @@ func rewriteValueMIPS64_OpHmul32u(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpHmul64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpHmul64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul64 x y) // cond: // result: (Select0 (MULV x y)) @@ -1934,16 +1998,20 @@ func rewriteValueMIPS64_OpHmul64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64MULV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64MULV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpHmul64u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpHmul64u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul64u x y) // cond: // result: (Select0 (MULVU x y)) @@ -1951,16 +2019,14 @@ func rewriteValueMIPS64_OpHmul64u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpInterCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpInterCall(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -1975,9 +2041,7 @@ func rewriteValueMIPS64_OpInterCall(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpIsInBounds(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpIsInBounds(v *Value) bool { // match: (IsInBounds idx len) // cond: // result: (SGTU len idx) @@ -1990,9 +2054,13 @@ func rewriteValueMIPS64_OpIsInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpIsNonNil(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpIsNonNil(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (IsNonNil ptr) // cond: // result: (SGTU ptr (MOVVconst [0])) @@ -2000,15 +2068,19 @@ func rewriteValueMIPS64_OpIsNonNil(v *Value, config *Config) bool { ptr := v.Args[0] v.reset(OpMIPS64SGTU) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpIsSliceInBounds(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpIsSliceInBounds(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (IsSliceInBounds idx len) // cond: // result: (XOR (MOVVconst [1]) (SGTU idx len)) @@ -2016,19 +2088,23 @@ func rewriteValueMIPS64_OpIsSliceInBounds(v *Value, config *Config) bool { idx := v.Args[0] len := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) v1.AddArg(idx) v1.AddArg(len) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLeq16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16 x y) // cond: // result: (XOR (MOVVconst [1]) (SGT (SignExt16to64 x) (SignExt16to64 y))) @@ -2036,23 +2112,27 @@ func rewriteValueMIPS64_OpLeq16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGT, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v3.AddArg(y) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLeq16U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16U x y) // cond: // result: (XOR (MOVVconst [1]) (SGTU (ZeroExt16to64 x) (ZeroExt16to64 y))) @@ -2060,23 +2140,27 @@ func rewriteValueMIPS64_OpLeq16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLeq32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq32 x y) // cond: // result: (XOR (MOVVconst [1]) (SGT (SignExt32to64 x) (SignExt32to64 y))) @@ -2084,21 +2168,21 @@ func rewriteValueMIPS64_OpLeq32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGT, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v3.AddArg(y) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLeq32F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq32F(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -2115,9 +2199,13 @@ func rewriteValueMIPS64_OpLeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLeq32U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq32U x y) // cond: // result: (XOR (MOVVconst [1]) (SGTU (ZeroExt32to64 x) (ZeroExt32to64 y))) @@ -2125,23 +2213,27 @@ func rewriteValueMIPS64_OpLeq32U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLeq64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq64 x y) // cond: // result: (XOR (MOVVconst [1]) (SGT x y)) @@ -2149,17 +2241,17 @@ func rewriteValueMIPS64_OpLeq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGT, config.fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool()) v1.AddArg(x) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLeq64F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq64F(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -2176,9 +2268,13 @@ func rewriteValueMIPS64_OpLeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLeq64U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq64U x y) // cond: // result: (XOR (MOVVconst [1]) (SGTU x y)) @@ -2186,19 +2282,23 @@ func rewriteValueMIPS64_OpLeq64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) v1.AddArg(x) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLeq8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8 x y) // cond: // result: (XOR (MOVVconst [1]) (SGT (SignExt8to64 x) (SignExt8to64 y))) @@ -2206,23 +2306,27 @@ func rewriteValueMIPS64_OpLeq8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGT, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v3.AddArg(y) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLeq8U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8U x y) // cond: // result: (XOR (MOVVconst [1]) (SGTU (ZeroExt8to64 x) (ZeroExt8to64 y))) @@ -2230,23 +2334,27 @@ func rewriteValueMIPS64_OpLeq8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64XOR) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 1 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLess16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLess16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16 x y) // cond: // result: (SGT (SignExt16to64 y) (SignExt16to64 x)) @@ -2254,18 +2362,22 @@ func rewriteValueMIPS64_OpLess16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGT) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLess16U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLess16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16U x y) // cond: // result: (SGTU (ZeroExt16to64 y) (ZeroExt16to64 x)) @@ -2273,18 +2385,22 @@ func rewriteValueMIPS64_OpLess16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLess32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLess32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less32 x y) // cond: // result: (SGT (SignExt32to64 y) (SignExt32to64 x)) @@ -2292,16 +2408,16 @@ func rewriteValueMIPS64_OpLess32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGT) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLess32F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLess32F(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -2318,9 +2434,13 @@ func rewriteValueMIPS64_OpLess32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLess32U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLess32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less32U x y) // cond: // result: (SGTU (ZeroExt32to64 y) (ZeroExt32to64 x)) @@ -2328,18 +2448,16 @@ func rewriteValueMIPS64_OpLess32U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLess64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpLess64(v *Value) bool { // match: (Less64 x y) // cond: // result: (SGT y x) @@ -2352,7 +2470,7 @@ func rewriteValueMIPS64_OpLess64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLess64F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLess64F(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -2369,9 +2487,7 @@ func rewriteValueMIPS64_OpLess64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLess64U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpLess64U(v *Value) bool { // match: (Less64U x y) // cond: // result: (SGTU y x) @@ -2384,9 +2500,13 @@ func rewriteValueMIPS64_OpLess64U(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLess8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLess8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8 x y) // cond: // result: (SGT (SignExt8to64 y) (SignExt8to64 x)) @@ -2394,18 +2514,22 @@ func rewriteValueMIPS64_OpLess8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGT) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLess8U(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLess8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8U x y) // cond: // result: (SGTU (ZeroExt8to64 y) (ZeroExt8to64 x)) @@ -2413,18 +2537,16 @@ func rewriteValueMIPS64_OpLess8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpLoad(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpLoad(v *Value) bool { // match: (Load <t> ptr mem) // cond: t.IsBoolean() // result: (MOVBUload ptr mem) @@ -2577,80 +2699,92 @@ func rewriteValueMIPS64_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpLsh16x16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x16 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh16x32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x32 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh16x64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x64 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) v1.AddArg(y) @@ -2663,110 +2797,126 @@ func rewriteValueMIPS64_OpLsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLsh16x8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x8 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh32x16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x16 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh32x32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh32x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x32 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh32x64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh32x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x64 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) v1.AddArg(y) @@ -2779,110 +2929,126 @@ func rewriteValueMIPS64_OpLsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLsh32x8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x8 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh64x16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x16 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh64x32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh64x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x32 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh64x64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh64x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x64 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) v1.AddArg(y) @@ -2895,110 +3061,126 @@ func rewriteValueMIPS64_OpLsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLsh64x8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x8 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh8x16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x16 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh8x32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x32 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpLsh8x64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x64 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) v1.AddArg(y) @@ -3011,39 +3193,41 @@ func rewriteValueMIPS64_OpLsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpLsh8x8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpLsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x8 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpMIPS64ADDV(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64ADDV(v *Value) bool { // match: (ADDV (MOVVconst [c]) x) // cond: is32Bit(c) // result: (ADDVconst [c] x) @@ -3112,9 +3296,7 @@ func rewriteValueMIPS64_OpMIPS64ADDV(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value) bool { // match: (ADDVconst [off1] (MOVVaddr [off2] {sym} ptr)) // cond: // result: (MOVVaddr [off1+off2] {sym} ptr) @@ -3200,9 +3382,7 @@ func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64AND(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64AND(v *Value) bool { // match: (AND (MOVVconst [c]) x) // cond: is32Bit(c) // result: (ANDconst [c] x) @@ -3254,9 +3434,7 @@ func rewriteValueMIPS64_OpMIPS64AND(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value) bool { // match: (ANDconst [0] _) // cond: // result: (MOVVconst [0]) @@ -3313,9 +3491,7 @@ func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value) bool { // match: (MOVBUload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVBUload [off1+off2] {sym} ptr mem) @@ -3365,9 +3541,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value) bool { // match: (MOVBUreg x:(MOVBUload _ _)) // cond: // result: (MOVVreg x) @@ -3407,9 +3581,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value) bool { // match: (MOVBload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -3459,9 +3631,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value) bool { // match: (MOVBreg x:(MOVBload _ _)) // cond: // result: (MOVVreg x) @@ -3501,9 +3671,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value) bool { // match: (MOVBstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVBstore [off1+off2] {sym} ptr val mem) @@ -3705,9 +3873,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value) bool { // match: (MOVBstorezero [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVBstorezero [off1+off2] {sym} ptr mem) @@ -3757,9 +3923,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value) bool { // match: (MOVDload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVDload [off1+off2] {sym} ptr mem) @@ -3809,9 +3973,7 @@ func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -3865,9 +4027,7 @@ func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value) bool { // match: (MOVFload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVFload [off1+off2] {sym} ptr mem) @@ -3917,9 +4077,7 @@ func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value) bool { // match: (MOVFstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVFstore [off1+off2] {sym} ptr val mem) @@ -3973,9 +4131,7 @@ func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value) bool { // match: (MOVHUload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVHUload [off1+off2] {sym} ptr mem) @@ -4025,9 +4181,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value) bool { // match: (MOVHUreg x:(MOVBUload _ _)) // cond: // result: (MOVVreg x) @@ -4091,9 +4245,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool { // match: (MOVHload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -4143,9 +4295,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value) bool { // match: (MOVHreg x:(MOVBload _ _)) // cond: // result: (MOVVreg x) @@ -4233,9 +4383,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value) bool { // match: (MOVHstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVHstore [off1+off2] {sym} ptr val mem) @@ -4395,9 +4543,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value) bool { // match: (MOVHstorezero [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVHstorezero [off1+off2] {sym} ptr mem) @@ -4447,9 +4593,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool { // match: (MOVVload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVVload [off1+off2] {sym} ptr mem) @@ -4499,9 +4643,7 @@ func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value) bool { // match: (MOVVreg x) // cond: x.Uses == 1 // result: (MOVVnop x) @@ -4529,9 +4671,7 @@ func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value) bool { // match: (MOVVstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVVstore [off1+off2] {sym} ptr val mem) @@ -4607,9 +4747,7 @@ func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value) bool { // match: (MOVVstorezero [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVVstorezero [off1+off2] {sym} ptr mem) @@ -4659,9 +4797,7 @@ func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value) bool { // match: (MOVWUload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVWUload [off1+off2] {sym} ptr mem) @@ -4711,9 +4847,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value) bool { // match: (MOVWUreg x:(MOVBUload _ _)) // cond: // result: (MOVVreg x) @@ -4801,9 +4935,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool { // match: (MOVWload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVWload [off1+off2] {sym} ptr mem) @@ -4853,9 +4985,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool { // match: (MOVWreg x:(MOVBload _ _)) // cond: // result: (MOVVreg x) @@ -4991,9 +5121,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value) bool { // match: (MOVWstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVWstore [off1+off2] {sym} ptr val mem) @@ -5111,9 +5239,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value) bool { // match: (MOVWstorezero [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVWstorezero [off1+off2] {sym} ptr mem) @@ -5163,9 +5289,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64NEGV(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64NEGV(v *Value) bool { // match: (NEGV (MOVVconst [c])) // cond: // result: (MOVVconst [-c]) @@ -5181,9 +5305,7 @@ func rewriteValueMIPS64_OpMIPS64NEGV(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64NOR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64NOR(v *Value) bool { // match: (NOR (MOVVconst [c]) x) // cond: is32Bit(c) // result: (NORconst [c] x) @@ -5222,9 +5344,7 @@ func rewriteValueMIPS64_OpMIPS64NOR(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64NORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64NORconst(v *Value) bool { // match: (NORconst [c] (MOVVconst [d])) // cond: // result: (MOVVconst [^(c|d)]) @@ -5241,9 +5361,7 @@ func rewriteValueMIPS64_OpMIPS64NORconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64OR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64OR(v *Value) bool { // match: (OR (MOVVconst [c]) x) // cond: is32Bit(c) // result: (ORconst [c] x) @@ -5295,9 +5413,7 @@ func rewriteValueMIPS64_OpMIPS64OR(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64ORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64ORconst(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -5357,9 +5473,7 @@ func rewriteValueMIPS64_OpMIPS64ORconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SGT(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SGT(v *Value) bool { // match: (SGT (MOVVconst [c]) x) // cond: is32Bit(c) // result: (SGTconst [c] x) @@ -5380,9 +5494,7 @@ func rewriteValueMIPS64_OpMIPS64SGT(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SGTU(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SGTU(v *Value) bool { // match: (SGTU (MOVVconst [c]) x) // cond: is32Bit(c) // result: (SGTUconst [c] x) @@ -5403,9 +5515,7 @@ func rewriteValueMIPS64_OpMIPS64SGTU(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value) bool { // match: (SGTUconst [c] (MOVVconst [d])) // cond: uint64(c)>uint64(d) // result: (MOVVconst [1]) @@ -5508,9 +5618,7 @@ func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value) bool { // match: (SGTconst [c] (MOVVconst [d])) // cond: int64(c)>int64(d) // result: (MOVVconst [1]) @@ -5725,9 +5833,7 @@ func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SLLV(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SLLV(v *Value) bool { // match: (SLLV _ (MOVVconst [c])) // cond: uint64(c)>=64 // result: (MOVVconst [0]) @@ -5761,9 +5867,7 @@ func rewriteValueMIPS64_OpMIPS64SLLV(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SLLVconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SLLVconst(v *Value) bool { // match: (SLLVconst [c] (MOVVconst [d])) // cond: // result: (MOVVconst [int64(d)<<uint64(c)]) @@ -5780,9 +5884,7 @@ func rewriteValueMIPS64_OpMIPS64SLLVconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SRAV(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SRAV(v *Value) bool { // match: (SRAV x (MOVVconst [c])) // cond: uint64(c)>=64 // result: (SRAVconst x [63]) @@ -5818,9 +5920,7 @@ func rewriteValueMIPS64_OpMIPS64SRAV(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value) bool { // match: (SRAVconst [c] (MOVVconst [d])) // cond: // result: (MOVVconst [int64(d)>>uint64(c)]) @@ -5837,9 +5937,7 @@ func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SRLV(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SRLV(v *Value) bool { // match: (SRLV _ (MOVVconst [c])) // cond: uint64(c)>=64 // result: (MOVVconst [0]) @@ -5873,9 +5971,7 @@ func rewriteValueMIPS64_OpMIPS64SRLV(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value) bool { // match: (SRLVconst [c] (MOVVconst [d])) // cond: // result: (MOVVconst [int64(uint64(d)>>uint64(c))]) @@ -5892,9 +5988,7 @@ func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SUBV(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SUBV(v *Value) bool { // match: (SUBV x (MOVVconst [c])) // cond: is32Bit(c) // result: (SUBVconst [c] x) @@ -5943,9 +6037,7 @@ func rewriteValueMIPS64_OpMIPS64SUBV(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value) bool { // match: (SUBVconst [0] x) // cond: // result: x @@ -6013,9 +6105,7 @@ func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64XOR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64XOR(v *Value) bool { // match: (XOR (MOVVconst [c]) x) // cond: is32Bit(c) // result: (XORconst [c] x) @@ -6066,9 +6156,7 @@ func rewriteValueMIPS64_OpMIPS64XOR(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMIPS64XORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMIPS64XORconst(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -6130,9 +6218,13 @@ func rewriteValueMIPS64_OpMIPS64XORconst(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMod16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMod16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16 x y) // cond: // result: (Select0 (DIVV (SignExt16to64 x) (SignExt16to64 y))) @@ -6140,20 +6232,24 @@ func rewriteValueMIPS64_OpMod16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) - v1 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) + v1 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMod16u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMod16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16u x y) // cond: // result: (Select0 (DIVVU (ZeroExt16to64 x) (ZeroExt16to64 y))) @@ -6161,20 +6257,24 @@ func rewriteValueMIPS64_OpMod16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) - v1 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) + v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMod32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMod32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32 x y) // cond: // result: (Select0 (DIVV (SignExt32to64 x) (SignExt32to64 y))) @@ -6182,20 +6282,24 @@ func rewriteValueMIPS64_OpMod32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) - v1 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) + v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMod32u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMod32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32u x y) // cond: // result: (Select0 (DIVVU (ZeroExt32to64 x) (ZeroExt32to64 y))) @@ -6203,20 +6307,24 @@ func rewriteValueMIPS64_OpMod32u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMod64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMod64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod64 x y) // cond: // result: (Select0 (DIVV x y)) @@ -6224,16 +6332,20 @@ func rewriteValueMIPS64_OpMod64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMod64u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMod64u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod64u x y) // cond: // result: (Select0 (DIVVU x y)) @@ -6241,16 +6353,20 @@ func rewriteValueMIPS64_OpMod64u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMod8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMod8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8 x y) // cond: // result: (Select0 (DIVV (SignExt8to64 x) (SignExt8to64 y))) @@ -6258,20 +6374,24 @@ func rewriteValueMIPS64_OpMod8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(config.fe.TypeInt64(), config.fe.TypeInt64())) - v1 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) + v1 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMod8u(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMod8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8u x y) // cond: // result: (Select0 (DIVVU (ZeroExt8to64 x) (ZeroExt8to64 y))) @@ -6279,20 +6399,24 @@ func rewriteValueMIPS64_OpMod8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect0) - v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMove(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Move [0] _ _ mem) // cond: // result: mem @@ -6318,7 +6442,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpMIPS64MOVBstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -6341,7 +6465,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { } v.reset(OpMIPS64MOVHstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -6361,14 +6485,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVBstore) v.AuxInt = 1 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v0.AuxInt = 1 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -6392,7 +6516,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { } v.reset(OpMIPS64MOVWstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -6416,14 +6540,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVHstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -6444,7 +6568,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVBstore) v.AuxInt = 3 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v0.AuxInt = 3 v0.AddArg(src) v0.AddArg(mem) @@ -6452,7 +6576,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v1.AuxInt = 2 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v2.AuxInt = 2 v2.AddArg(src) v2.AddArg(mem) @@ -6460,14 +6584,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v3.AuxInt = 1 v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v4.AuxInt = 1 v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v5.AddArg(dst) - v6 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v6 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v6.AddArg(src) v6.AddArg(mem) v5.AddArg(v6) @@ -6493,7 +6617,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { } v.reset(OpMIPS64MOVVstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -6517,14 +6641,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVWstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVWload, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -6549,7 +6673,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVHstore) v.AuxInt = 6 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v0.AuxInt = 6 v0.AddArg(src) v0.AddArg(mem) @@ -6557,7 +6681,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v1.AuxInt = 4 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v2.AuxInt = 4 v2.AddArg(src) v2.AddArg(mem) @@ -6565,14 +6689,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v3.AuxInt = 2 v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v4.AuxInt = 2 v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v5.AddArg(dst) - v6 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v6 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v6.AddArg(src) v6.AddArg(mem) v5.AddArg(v6) @@ -6595,7 +6719,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVBstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) @@ -6603,14 +6727,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v1.AuxInt = 1 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v2.AuxInt = 1 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -6636,7 +6760,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVHstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) @@ -6644,14 +6768,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v1.AuxInt = 2 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v2.AuxInt = 2 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVHload, config.fe.TypeInt16()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -6677,7 +6801,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVWstore) v.AuxInt = 8 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32()) v0.AuxInt = 8 v0.AddArg(src) v0.AddArg(mem) @@ -6685,14 +6809,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem) v1.AuxInt = 4 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVWload, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32()) v2.AuxInt = 4 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVWload, config.fe.TypeInt32()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -6718,14 +6842,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVVstore) v.AuxInt = 8 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64()) v0.AuxInt = 8 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVload, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -6750,7 +6874,7 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v.reset(OpMIPS64MOVVstore) v.AuxInt = 16 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64()) v0.AuxInt = 16 v0.AddArg(src) v0.AddArg(mem) @@ -6758,14 +6882,14 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem) v1.AuxInt = 8 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVload, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64()) v2.AuxInt = 8 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVVload, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -6799,9 +6923,13 @@ func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpMul16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMul16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mul16 x y) // cond: // result: (Select1 (MULVU x y)) @@ -6809,16 +6937,20 @@ func rewriteValueMIPS64_OpMul16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMul32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMul32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mul32 x y) // cond: // result: (Select1 (MULVU x y)) @@ -6826,16 +6958,14 @@ func rewriteValueMIPS64_OpMul32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMul32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMul32F(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULF x y) @@ -6848,9 +6978,13 @@ func rewriteValueMIPS64_OpMul32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpMul64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMul64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mul64 x y) // cond: // result: (Select1 (MULVU x y)) @@ -6858,16 +6992,14 @@ func rewriteValueMIPS64_OpMul64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpMul64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpMul64F(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULD x y) @@ -6880,9 +7012,13 @@ func rewriteValueMIPS64_OpMul64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpMul8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpMul8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mul8 x y) // cond: // result: (Select1 (MULVU x y)) @@ -6890,16 +7026,14 @@ func rewriteValueMIPS64_OpMul8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpSelect1) - v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(config.fe.TypeUInt64(), config.fe.TypeUInt64())) + v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpNeg16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpNeg16(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEGV x) @@ -6910,9 +7044,7 @@ func rewriteValueMIPS64_OpNeg16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNeg32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpNeg32(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEGV x) @@ -6923,9 +7055,7 @@ func rewriteValueMIPS64_OpNeg32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNeg32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpNeg32F(v *Value) bool { // match: (Neg32F x) // cond: // result: (NEGF x) @@ -6936,9 +7066,7 @@ func rewriteValueMIPS64_OpNeg32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNeg64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpNeg64(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEGV x) @@ -6949,9 +7077,7 @@ func rewriteValueMIPS64_OpNeg64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNeg64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpNeg64F(v *Value) bool { // match: (Neg64F x) // cond: // result: (NEGD x) @@ -6962,9 +7088,7 @@ func rewriteValueMIPS64_OpNeg64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNeg8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpNeg8(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEGV x) @@ -6975,9 +7099,13 @@ func rewriteValueMIPS64_OpNeg8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNeq16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpNeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq16 x y) // cond: // result: (SGTU (XOR (ZeroExt16to32 x) (ZeroExt16to64 y)) (MOVVconst [0])) @@ -6985,23 +7113,27 @@ func rewriteValueMIPS64_OpNeq16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v3.AuxInt = 0 v.AddArg(v3) return true } } -func rewriteValueMIPS64_OpNeq32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpNeq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq32 x y) // cond: // result: (SGTU (XOR (ZeroExt32to64 x) (ZeroExt32to64 y)) (MOVVconst [0])) @@ -7009,21 +7141,21 @@ func rewriteValueMIPS64_OpNeq32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v3.AuxInt = 0 v.AddArg(v3) return true } } -func rewriteValueMIPS64_OpNeq32F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpNeq32F(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -7040,9 +7172,13 @@ func rewriteValueMIPS64_OpNeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNeq64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpNeq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq64 x y) // cond: // result: (SGTU (XOR x y) (MOVVconst [0])) @@ -7050,17 +7186,17 @@ func rewriteValueMIPS64_OpNeq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v1.AuxInt = 0 v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpNeq64F(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpNeq64F(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -7077,9 +7213,13 @@ func rewriteValueMIPS64_OpNeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNeq8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpNeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq8 x y) // cond: // result: (SGTU (XOR (ZeroExt8to64 x) (ZeroExt8to64 y)) (MOVVconst [0])) @@ -7087,23 +7227,21 @@ func rewriteValueMIPS64_OpNeq8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v3.AuxInt = 0 v.AddArg(v3) return true } } -func rewriteValueMIPS64_OpNeqB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpNeqB(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -7116,9 +7254,13 @@ func rewriteValueMIPS64_OpNeqB(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNeqPtr(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpNeqPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (NeqPtr x y) // cond: // result: (SGTU (XOR x y) (MOVVconst [0])) @@ -7126,19 +7268,17 @@ func rewriteValueMIPS64_OpNeqPtr(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SGTU) - v0 := b.NewValue0(v.Pos, OpMIPS64XOR, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v1.AuxInt = 0 v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpNilCheck(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpNilCheck(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -7151,9 +7291,7 @@ func rewriteValueMIPS64_OpNilCheck(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpNot(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpNot(v *Value) bool { // match: (Not x) // cond: // result: (XORconst [1] x) @@ -7165,9 +7303,7 @@ func rewriteValueMIPS64_OpNot(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpOffPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpOffPtr(v *Value) bool { // match: (OffPtr [off] ptr:(SP)) // cond: // result: (MOVVaddr [off] ptr) @@ -7194,9 +7330,7 @@ func rewriteValueMIPS64_OpOffPtr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpOr16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpOr16(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -7209,9 +7343,7 @@ func rewriteValueMIPS64_OpOr16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpOr32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpOr32(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -7224,9 +7356,7 @@ func rewriteValueMIPS64_OpOr32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpOr64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpOr64(v *Value) bool { // match: (Or64 x y) // cond: // result: (OR x y) @@ -7239,9 +7369,7 @@ func rewriteValueMIPS64_OpOr64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpOr8(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -7254,9 +7382,7 @@ func rewriteValueMIPS64_OpOr8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpOrB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpOrB(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -7269,9 +7395,7 @@ func rewriteValueMIPS64_OpOrB(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpRound32F(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -7283,9 +7407,7 @@ func rewriteValueMIPS64_OpRound32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpRound64F(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -7297,91 +7419,103 @@ func rewriteValueMIPS64_OpRound64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRsh16Ux16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh16Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux16 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v6.AddArg(y) v4.AddArg(v6) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh16Ux32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh16Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux32 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v6.AddArg(y) v4.AddArg(v6) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh16Ux64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh16Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux64 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y)) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) v3 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(x) v3.AddArg(v4) v3.AddArg(y) @@ -7389,121 +7523,137 @@ func rewriteValueMIPS64_OpRsh16Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRsh16Ux8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh16Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux8 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v6.AddArg(y) v4.AddArg(v6) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh16x16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x16 <t> x y) // cond: - // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) + // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v3.AddArg(v5) v2.AddArg(v3) v1.AddArg(v2) - v6 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v6.AddArg(y) v1.AddArg(v6) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpRsh16x32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x32 <t> x y) // cond: - // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) + // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v3.AddArg(v5) v2.AddArg(v3) v1.AddArg(v2) - v6 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v6.AddArg(y) v1.AddArg(v6) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpRsh16x64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x64 <t> x y) // cond: - // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <config.fe.TypeUInt64()> [63]))) y)) + // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) v3.AddArg(y) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 63 v3.AddArg(v4) v2.AddArg(v3) @@ -7513,123 +7663,139 @@ func rewriteValueMIPS64_OpRsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRsh16x8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x8 <t> x y) // cond: - // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) + // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt16to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v3.AddArg(v5) v2.AddArg(v3) v1.AddArg(v2) - v6 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v6.AddArg(y) v1.AddArg(v6) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpRsh32Ux16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh32Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux16 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v6.AddArg(y) v4.AddArg(v6) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh32Ux32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh32Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux32 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v6.AddArg(y) v4.AddArg(v6) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh32Ux64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh32Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux64 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y)) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) v3 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(x) v3.AddArg(v4) v3.AddArg(y) @@ -7637,121 +7803,137 @@ func rewriteValueMIPS64_OpRsh32Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRsh32Ux8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh32Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux8 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v6.AddArg(y) v4.AddArg(v6) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh32x16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x16 <t> x y) // cond: - // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) + // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v3.AddArg(v5) v2.AddArg(v3) v1.AddArg(v2) - v6 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v6.AddArg(y) v1.AddArg(v6) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpRsh32x32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh32x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x32 <t> x y) // cond: - // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) + // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v3.AddArg(v5) v2.AddArg(v3) v1.AddArg(v2) - v6 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v6.AddArg(y) v1.AddArg(v6) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpRsh32x64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh32x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x64 <t> x y) // cond: - // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <config.fe.TypeUInt64()> [63]))) y)) + // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) v3.AddArg(y) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 63 v3.AddArg(v4) v2.AddArg(v3) @@ -7761,112 +7943,128 @@ func rewriteValueMIPS64_OpRsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRsh32x8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x8 <t> x y) // cond: - // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) + // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v3.AddArg(v5) v2.AddArg(v3) v1.AddArg(v2) - v6 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v6.AddArg(y) v1.AddArg(v6) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpRsh64Ux16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh64Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux16 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh64Ux32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh64Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux32 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh64Ux64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh64Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux64 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SRLV <t> x y)) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> x y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) v1.AddArg(y) @@ -7879,42 +8077,50 @@ func rewriteValueMIPS64_OpRsh64Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRsh64Ux8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh64Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux8 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh64x16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x16 <t> x y) // cond: - // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) + // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] @@ -7923,28 +8129,32 @@ func rewriteValueMIPS64_OpRsh64x16(v *Value, config *Config) bool { v.AddArg(x) v0 := b.NewValue0(v.Pos, OpMIPS64OR, t) v1 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 63 v2.AddArg(v4) v1.AddArg(v2) v0.AddArg(v1) - v5 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v5.AddArg(y) v0.AddArg(v5) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpRsh64x32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh64x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x32 <t> x y) // cond: - // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) + // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] @@ -7953,28 +8163,32 @@ func rewriteValueMIPS64_OpRsh64x32(v *Value, config *Config) bool { v.AddArg(x) v0 := b.NewValue0(v.Pos, OpMIPS64OR, t) v1 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 63 v2.AddArg(v4) v1.AddArg(v2) v0.AddArg(v1) - v5 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v5.AddArg(y) v0.AddArg(v5) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpRsh64x64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh64x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x64 <t> x y) // cond: - // result: (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <config.fe.TypeUInt64()> [63]))) y)) + // result: (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) for { t := v.Type x := v.Args[0] @@ -7983,9 +8197,9 @@ func rewriteValueMIPS64_OpRsh64x64(v *Value, config *Config) bool { v.AddArg(x) v0 := b.NewValue0(v.Pos, OpMIPS64OR, t) v1 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) v2.AddArg(y) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = 63 v2.AddArg(v3) v1.AddArg(v2) @@ -7995,12 +8209,16 @@ func rewriteValueMIPS64_OpRsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRsh64x8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x8 <t> x y) // cond: - // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) + // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] @@ -8009,107 +8227,119 @@ func rewriteValueMIPS64_OpRsh64x8(v *Value, config *Config) bool { v.AddArg(x) v0 := b.NewValue0(v.Pos, OpMIPS64OR, t) v1 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 63 v2.AddArg(v4) v1.AddArg(v2) v0.AddArg(v1) - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(y) v0.AddArg(v5) v.AddArg(v0) return true } } -func rewriteValueMIPS64_OpRsh8Ux16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh8Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux16 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v6.AddArg(y) v4.AddArg(v6) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh8Ux32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh8Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux32 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v6.AddArg(y) v4.AddArg(v6) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh8Ux64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh8Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux64 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y)) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) v1.AddArg(y) v0.AddArg(v1) v.AddArg(v0) v3 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(x) v3.AddArg(v4) v3.AddArg(y) @@ -8117,121 +8347,137 @@ func rewriteValueMIPS64_OpRsh8Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRsh8Ux8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh8Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux8 <t> x y) // cond: - // result: (AND (NEGV <t> (SGTU (Const64 <config.fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y))) + // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64AND) v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 64 v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t) - v5 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v6.AddArg(y) v4.AddArg(v6) v.AddArg(v4) return true } } -func rewriteValueMIPS64_OpRsh8x16(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x16 <t> x y) // cond: - // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) + // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v3.AddArg(v5) v2.AddArg(v3) v1.AddArg(v2) - v6 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v6.AddArg(y) v1.AddArg(v6) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpRsh8x32(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x32 <t> x y) // cond: - // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) + // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v3.AddArg(v5) v2.AddArg(v3) v1.AddArg(v2) - v6 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v6.AddArg(y) v1.AddArg(v6) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpRsh8x64(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x64 <t> x y) // cond: - // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <config.fe.TypeUInt64()> [63]))) y)) + // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) v3.AddArg(y) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 63 v3.AddArg(v4) v2.AddArg(v3) @@ -8241,41 +8487,43 @@ func rewriteValueMIPS64_OpRsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpRsh8x8(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpRsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x8 <t> x y) // cond: - // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <config.fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) + // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) for { t := v.Type x := v.Args[0] y := v.Args[1] v.reset(OpMIPS64SRAV) - v0 := b.NewValue0(v.Pos, OpSignExt8to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64OR, t) v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t) - v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v3.AddArg(v5) v2.AddArg(v3) v1.AddArg(v2) - v6 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v6.AddArg(y) v1.AddArg(v6) v.AddArg(v1) return true } } -func rewriteValueMIPS64_OpSelect0(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSelect0(v *Value) bool { // match: (Select0 (DIVVU _ (MOVVconst [1]))) // cond: // result: (MOVVconst [0]) @@ -8363,9 +8611,7 @@ func rewriteValueMIPS64_OpSelect0(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpSelect1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSelect1(v *Value) bool { // match: (Select1 (MULVU x (MOVVconst [-1]))) // cond: // result: (NEGV x) @@ -8641,9 +8887,7 @@ func rewriteValueMIPS64_OpSelect1(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpSignExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSignExt16to32(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -8654,9 +8898,7 @@ func rewriteValueMIPS64_OpSignExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSignExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSignExt16to64(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVHreg x) @@ -8667,9 +8909,7 @@ func rewriteValueMIPS64_OpSignExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSignExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSignExt32to64(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVWreg x) @@ -8680,9 +8920,7 @@ func rewriteValueMIPS64_OpSignExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSignExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSignExt8to16(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -8693,9 +8931,7 @@ func rewriteValueMIPS64_OpSignExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSignExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSignExt8to32(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -8706,9 +8942,7 @@ func rewriteValueMIPS64_OpSignExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSignExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSignExt8to64(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBreg x) @@ -8719,7 +8953,7 @@ func rewriteValueMIPS64_OpSignExt8to64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSlicemask(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpSlicemask(v *Value) bool { b := v.Block _ = b // match: (Slicemask <t> x) @@ -8736,9 +8970,7 @@ func rewriteValueMIPS64_OpSlicemask(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpStaticCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpStaticCall(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -8753,9 +8985,7 @@ func rewriteValueMIPS64_OpStaticCall(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpStore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpStore(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 1 // result: (MOVBstore ptr val mem) @@ -8860,9 +9090,7 @@ func rewriteValueMIPS64_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpSub16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSub16(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUBV x y) @@ -8875,9 +9103,7 @@ func rewriteValueMIPS64_OpSub16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSub32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSub32(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUBV x y) @@ -8890,9 +9116,7 @@ func rewriteValueMIPS64_OpSub32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSub32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSub32F(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBF x y) @@ -8905,9 +9129,7 @@ func rewriteValueMIPS64_OpSub32F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSub64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSub64(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUBV x y) @@ -8920,9 +9142,7 @@ func rewriteValueMIPS64_OpSub64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSub64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSub64F(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBD x y) @@ -8935,9 +9155,7 @@ func rewriteValueMIPS64_OpSub64F(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSub8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSub8(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUBV x y) @@ -8950,9 +9168,7 @@ func rewriteValueMIPS64_OpSub8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpSubPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpSubPtr(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUBV x y) @@ -8965,9 +9181,7 @@ func rewriteValueMIPS64_OpSubPtr(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpTrunc16to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpTrunc16to8(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -8979,9 +9193,7 @@ func rewriteValueMIPS64_OpTrunc16to8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpTrunc32to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpTrunc32to16(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -8993,9 +9205,7 @@ func rewriteValueMIPS64_OpTrunc32to16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpTrunc32to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpTrunc32to8(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -9007,9 +9217,7 @@ func rewriteValueMIPS64_OpTrunc32to8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpTrunc64to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpTrunc64to16(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: x @@ -9021,9 +9229,7 @@ func rewriteValueMIPS64_OpTrunc64to16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpTrunc64to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpTrunc64to32(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: x @@ -9035,9 +9241,7 @@ func rewriteValueMIPS64_OpTrunc64to32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpTrunc64to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpTrunc64to8(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: x @@ -9049,9 +9253,7 @@ func rewriteValueMIPS64_OpTrunc64to8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpXor16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpXor16(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -9064,9 +9266,7 @@ func rewriteValueMIPS64_OpXor16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpXor32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpXor32(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -9079,9 +9279,7 @@ func rewriteValueMIPS64_OpXor32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpXor64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpXor64(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XOR x y) @@ -9094,9 +9292,7 @@ func rewriteValueMIPS64_OpXor64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpXor8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpXor8(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -9109,9 +9305,13 @@ func rewriteValueMIPS64_OpXor8(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { +func rewriteValueMIPS64_OpZero(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Zero [0] _ mem) // cond: // result: mem @@ -9136,7 +9336,7 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { mem := v.Args[1] v.reset(OpMIPS64MOVBstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -9157,7 +9357,7 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { } v.reset(OpMIPS64MOVHstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -9175,13 +9375,13 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVBstore) v.AuxInt = 1 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v1.AuxInt = 0 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -9203,7 +9403,7 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { } v.reset(OpMIPS64MOVWstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -9225,13 +9425,13 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVHstore) v.AuxInt = 2 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v1.AuxInt = 0 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -9250,25 +9450,25 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVBstore) v.AuxInt = 3 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v1.AuxInt = 2 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v3.AuxInt = 1 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v4.AuxInt = 0 v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v5.AuxInt = 0 v5.AddArg(ptr) - v6 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v6.AuxInt = 0 v5.AddArg(v6) v5.AddArg(mem) @@ -9292,7 +9492,7 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { } v.reset(OpMIPS64MOVVstore) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) @@ -9314,13 +9514,13 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVWstore) v.AuxInt = 4 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem) v1.AuxInt = 0 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -9343,25 +9543,25 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVHstore) v.AuxInt = 6 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v1.AuxInt = 4 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v3.AuxInt = 2 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v4.AuxInt = 0 v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v5.AuxInt = 0 v5.AddArg(ptr) - v6 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v6.AuxInt = 0 v5.AddArg(v6) v5.AddArg(mem) @@ -9382,19 +9582,19 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVBstore) v.AuxInt = 2 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v1.AuxInt = 1 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem) v3.AuxInt = 0 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -9418,19 +9618,19 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVHstore) v.AuxInt = 4 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v1.AuxInt = 2 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem) v3.AuxInt = 0 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -9454,19 +9654,19 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVWstore) v.AuxInt = 8 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem) v1.AuxInt = 4 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem) v3.AuxInt = 0 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -9490,13 +9690,13 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVVstore) v.AuxInt = 8 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem) v1.AuxInt = 0 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v1.AddArg(mem) @@ -9519,19 +9719,19 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { v.reset(OpMIPS64MOVVstore) v.AuxInt = 16 v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem) v1.AuxInt = 8 v1.AddArg(ptr) - v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v2.AuxInt = 0 v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem) v3.AuxInt = 0 v3.AddArg(ptr) - v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64()) v4.AuxInt = 0 v3.AddArg(v4) v3.AddArg(mem) @@ -9579,9 +9779,7 @@ func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool { } return false } -func rewriteValueMIPS64_OpZeroExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpZeroExt16to32(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHUreg x) @@ -9592,9 +9790,7 @@ func rewriteValueMIPS64_OpZeroExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpZeroExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpZeroExt16to64(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVHUreg x) @@ -9605,9 +9801,7 @@ func rewriteValueMIPS64_OpZeroExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpZeroExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpZeroExt32to64(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVWUreg x) @@ -9618,9 +9812,7 @@ func rewriteValueMIPS64_OpZeroExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpZeroExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpZeroExt8to16(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBUreg x) @@ -9631,9 +9823,7 @@ func rewriteValueMIPS64_OpZeroExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpZeroExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpZeroExt8to32(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBUreg x) @@ -9644,9 +9834,7 @@ func rewriteValueMIPS64_OpZeroExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueMIPS64_OpZeroExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueMIPS64_OpZeroExt8to64(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBUreg x) @@ -9657,7 +9845,11 @@ func rewriteValueMIPS64_OpZeroExt8to64(v *Value, config *Config) bool { return true } } -func rewriteBlockMIPS64(b *Block, config *Config) bool { +func rewriteBlockMIPS64(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { case BlockMIPS64EQ: // match: (EQ (FPFlagTrue cmp) yes no) diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go index 49f469f535..dbe7553a61 100644 --- a/src/cmd/compile/internal/ssa/rewritePPC64.go +++ b/src/cmd/compile/internal/ssa/rewritePPC64.go @@ -6,592 +6,590 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValuePPC64(v *Value, config *Config) bool { +func rewriteValuePPC64(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValuePPC64_OpAdd16(v, config) + return rewriteValuePPC64_OpAdd16(v) case OpAdd32: - return rewriteValuePPC64_OpAdd32(v, config) + return rewriteValuePPC64_OpAdd32(v) case OpAdd32F: - return rewriteValuePPC64_OpAdd32F(v, config) + return rewriteValuePPC64_OpAdd32F(v) case OpAdd64: - return rewriteValuePPC64_OpAdd64(v, config) + return rewriteValuePPC64_OpAdd64(v) case OpAdd64F: - return rewriteValuePPC64_OpAdd64F(v, config) + return rewriteValuePPC64_OpAdd64F(v) case OpAdd8: - return rewriteValuePPC64_OpAdd8(v, config) + return rewriteValuePPC64_OpAdd8(v) case OpAddPtr: - return rewriteValuePPC64_OpAddPtr(v, config) + return rewriteValuePPC64_OpAddPtr(v) case OpAddr: - return rewriteValuePPC64_OpAddr(v, config) + return rewriteValuePPC64_OpAddr(v) case OpAnd16: - return rewriteValuePPC64_OpAnd16(v, config) + return rewriteValuePPC64_OpAnd16(v) case OpAnd32: - return rewriteValuePPC64_OpAnd32(v, config) + return rewriteValuePPC64_OpAnd32(v) case OpAnd64: - return rewriteValuePPC64_OpAnd64(v, config) + return rewriteValuePPC64_OpAnd64(v) case OpAnd8: - return rewriteValuePPC64_OpAnd8(v, config) + return rewriteValuePPC64_OpAnd8(v) case OpAndB: - return rewriteValuePPC64_OpAndB(v, config) + return rewriteValuePPC64_OpAndB(v) case OpAtomicAdd32: - return rewriteValuePPC64_OpAtomicAdd32(v, config) + return rewriteValuePPC64_OpAtomicAdd32(v) case OpAtomicAdd64: - return rewriteValuePPC64_OpAtomicAdd64(v, config) + return rewriteValuePPC64_OpAtomicAdd64(v) case OpAtomicAnd8: - return rewriteValuePPC64_OpAtomicAnd8(v, config) + return rewriteValuePPC64_OpAtomicAnd8(v) case OpAtomicCompareAndSwap32: - return rewriteValuePPC64_OpAtomicCompareAndSwap32(v, config) + return rewriteValuePPC64_OpAtomicCompareAndSwap32(v) case OpAtomicCompareAndSwap64: - return rewriteValuePPC64_OpAtomicCompareAndSwap64(v, config) + return rewriteValuePPC64_OpAtomicCompareAndSwap64(v) case OpAtomicExchange32: - return rewriteValuePPC64_OpAtomicExchange32(v, config) + return rewriteValuePPC64_OpAtomicExchange32(v) case OpAtomicExchange64: - return rewriteValuePPC64_OpAtomicExchange64(v, config) + return rewriteValuePPC64_OpAtomicExchange64(v) case OpAtomicLoad32: - return rewriteValuePPC64_OpAtomicLoad32(v, config) + return rewriteValuePPC64_OpAtomicLoad32(v) case OpAtomicLoad64: - return rewriteValuePPC64_OpAtomicLoad64(v, config) + return rewriteValuePPC64_OpAtomicLoad64(v) case OpAtomicLoadPtr: - return rewriteValuePPC64_OpAtomicLoadPtr(v, config) + return rewriteValuePPC64_OpAtomicLoadPtr(v) case OpAtomicOr8: - return rewriteValuePPC64_OpAtomicOr8(v, config) + return rewriteValuePPC64_OpAtomicOr8(v) case OpAtomicStore32: - return rewriteValuePPC64_OpAtomicStore32(v, config) + return rewriteValuePPC64_OpAtomicStore32(v) case OpAtomicStore64: - return rewriteValuePPC64_OpAtomicStore64(v, config) + return rewriteValuePPC64_OpAtomicStore64(v) case OpAvg64u: - return rewriteValuePPC64_OpAvg64u(v, config) + return rewriteValuePPC64_OpAvg64u(v) case OpClosureCall: - return rewriteValuePPC64_OpClosureCall(v, config) + return rewriteValuePPC64_OpClosureCall(v) case OpCom16: - return rewriteValuePPC64_OpCom16(v, config) + return rewriteValuePPC64_OpCom16(v) case OpCom32: - return rewriteValuePPC64_OpCom32(v, config) + return rewriteValuePPC64_OpCom32(v) case OpCom64: - return rewriteValuePPC64_OpCom64(v, config) + return rewriteValuePPC64_OpCom64(v) case OpCom8: - return rewriteValuePPC64_OpCom8(v, config) + return rewriteValuePPC64_OpCom8(v) case OpConst16: - return rewriteValuePPC64_OpConst16(v, config) + return rewriteValuePPC64_OpConst16(v) case OpConst32: - return rewriteValuePPC64_OpConst32(v, config) + return rewriteValuePPC64_OpConst32(v) case OpConst32F: - return rewriteValuePPC64_OpConst32F(v, config) + return rewriteValuePPC64_OpConst32F(v) case OpConst64: - return rewriteValuePPC64_OpConst64(v, config) + return rewriteValuePPC64_OpConst64(v) case OpConst64F: - return rewriteValuePPC64_OpConst64F(v, config) + return rewriteValuePPC64_OpConst64F(v) case OpConst8: - return rewriteValuePPC64_OpConst8(v, config) + return rewriteValuePPC64_OpConst8(v) case OpConstBool: - return rewriteValuePPC64_OpConstBool(v, config) + return rewriteValuePPC64_OpConstBool(v) case OpConstNil: - return rewriteValuePPC64_OpConstNil(v, config) + return rewriteValuePPC64_OpConstNil(v) case OpConvert: - return rewriteValuePPC64_OpConvert(v, config) + return rewriteValuePPC64_OpConvert(v) case OpCvt32Fto32: - return rewriteValuePPC64_OpCvt32Fto32(v, config) + return rewriteValuePPC64_OpCvt32Fto32(v) case OpCvt32Fto64: - return rewriteValuePPC64_OpCvt32Fto64(v, config) + return rewriteValuePPC64_OpCvt32Fto64(v) case OpCvt32Fto64F: - return rewriteValuePPC64_OpCvt32Fto64F(v, config) + return rewriteValuePPC64_OpCvt32Fto64F(v) case OpCvt32to32F: - return rewriteValuePPC64_OpCvt32to32F(v, config) + return rewriteValuePPC64_OpCvt32to32F(v) case OpCvt32to64F: - return rewriteValuePPC64_OpCvt32to64F(v, config) + return rewriteValuePPC64_OpCvt32to64F(v) case OpCvt64Fto32: - return rewriteValuePPC64_OpCvt64Fto32(v, config) + return rewriteValuePPC64_OpCvt64Fto32(v) case OpCvt64Fto32F: - return rewriteValuePPC64_OpCvt64Fto32F(v, config) + return rewriteValuePPC64_OpCvt64Fto32F(v) case OpCvt64Fto64: - return rewriteValuePPC64_OpCvt64Fto64(v, config) + return rewriteValuePPC64_OpCvt64Fto64(v) case OpCvt64to32F: - return rewriteValuePPC64_OpCvt64to32F(v, config) + return rewriteValuePPC64_OpCvt64to32F(v) case OpCvt64to64F: - return rewriteValuePPC64_OpCvt64to64F(v, config) + return rewriteValuePPC64_OpCvt64to64F(v) case OpDiv16: - return rewriteValuePPC64_OpDiv16(v, config) + return rewriteValuePPC64_OpDiv16(v) case OpDiv16u: - return rewriteValuePPC64_OpDiv16u(v, config) + return rewriteValuePPC64_OpDiv16u(v) case OpDiv32: - return rewriteValuePPC64_OpDiv32(v, config) + return rewriteValuePPC64_OpDiv32(v) case OpDiv32F: - return rewriteValuePPC64_OpDiv32F(v, config) + return rewriteValuePPC64_OpDiv32F(v) case OpDiv32u: - return rewriteValuePPC64_OpDiv32u(v, config) + return rewriteValuePPC64_OpDiv32u(v) case OpDiv64: - return rewriteValuePPC64_OpDiv64(v, config) + return rewriteValuePPC64_OpDiv64(v) case OpDiv64F: - return rewriteValuePPC64_OpDiv64F(v, config) + return rewriteValuePPC64_OpDiv64F(v) case OpDiv64u: - return rewriteValuePPC64_OpDiv64u(v, config) + return rewriteValuePPC64_OpDiv64u(v) case OpDiv8: - return rewriteValuePPC64_OpDiv8(v, config) + return rewriteValuePPC64_OpDiv8(v) case OpDiv8u: - return rewriteValuePPC64_OpDiv8u(v, config) + return rewriteValuePPC64_OpDiv8u(v) case OpEq16: - return rewriteValuePPC64_OpEq16(v, config) + return rewriteValuePPC64_OpEq16(v) case OpEq32: - return rewriteValuePPC64_OpEq32(v, config) + return rewriteValuePPC64_OpEq32(v) case OpEq32F: - return rewriteValuePPC64_OpEq32F(v, config) + return rewriteValuePPC64_OpEq32F(v) case OpEq64: - return rewriteValuePPC64_OpEq64(v, config) + return rewriteValuePPC64_OpEq64(v) case OpEq64F: - return rewriteValuePPC64_OpEq64F(v, config) + return rewriteValuePPC64_OpEq64F(v) case OpEq8: - return rewriteValuePPC64_OpEq8(v, config) + return rewriteValuePPC64_OpEq8(v) case OpEqB: - return rewriteValuePPC64_OpEqB(v, config) + return rewriteValuePPC64_OpEqB(v) case OpEqPtr: - return rewriteValuePPC64_OpEqPtr(v, config) + return rewriteValuePPC64_OpEqPtr(v) case OpGeq16: - return rewriteValuePPC64_OpGeq16(v, config) + return rewriteValuePPC64_OpGeq16(v) case OpGeq16U: - return rewriteValuePPC64_OpGeq16U(v, config) + return rewriteValuePPC64_OpGeq16U(v) case OpGeq32: - return rewriteValuePPC64_OpGeq32(v, config) + return rewriteValuePPC64_OpGeq32(v) case OpGeq32F: - return rewriteValuePPC64_OpGeq32F(v, config) + return rewriteValuePPC64_OpGeq32F(v) case OpGeq32U: - return rewriteValuePPC64_OpGeq32U(v, config) + return rewriteValuePPC64_OpGeq32U(v) case OpGeq64: - return rewriteValuePPC64_OpGeq64(v, config) + return rewriteValuePPC64_OpGeq64(v) case OpGeq64F: - return rewriteValuePPC64_OpGeq64F(v, config) + return rewriteValuePPC64_OpGeq64F(v) case OpGeq64U: - return rewriteValuePPC64_OpGeq64U(v, config) + return rewriteValuePPC64_OpGeq64U(v) case OpGeq8: - return rewriteValuePPC64_OpGeq8(v, config) + return rewriteValuePPC64_OpGeq8(v) case OpGeq8U: - return rewriteValuePPC64_OpGeq8U(v, config) + return rewriteValuePPC64_OpGeq8U(v) case OpGetClosurePtr: - return rewriteValuePPC64_OpGetClosurePtr(v, config) + return rewriteValuePPC64_OpGetClosurePtr(v) case OpGreater16: - return rewriteValuePPC64_OpGreater16(v, config) + return rewriteValuePPC64_OpGreater16(v) case OpGreater16U: - return rewriteValuePPC64_OpGreater16U(v, config) + return rewriteValuePPC64_OpGreater16U(v) case OpGreater32: - return rewriteValuePPC64_OpGreater32(v, config) + return rewriteValuePPC64_OpGreater32(v) case OpGreater32F: - return rewriteValuePPC64_OpGreater32F(v, config) + return rewriteValuePPC64_OpGreater32F(v) case OpGreater32U: - return rewriteValuePPC64_OpGreater32U(v, config) + return rewriteValuePPC64_OpGreater32U(v) case OpGreater64: - return rewriteValuePPC64_OpGreater64(v, config) + return rewriteValuePPC64_OpGreater64(v) case OpGreater64F: - return rewriteValuePPC64_OpGreater64F(v, config) + return rewriteValuePPC64_OpGreater64F(v) case OpGreater64U: - return rewriteValuePPC64_OpGreater64U(v, config) + return rewriteValuePPC64_OpGreater64U(v) case OpGreater8: - return rewriteValuePPC64_OpGreater8(v, config) + return rewriteValuePPC64_OpGreater8(v) case OpGreater8U: - return rewriteValuePPC64_OpGreater8U(v, config) + return rewriteValuePPC64_OpGreater8U(v) case OpHmul32: - return rewriteValuePPC64_OpHmul32(v, config) + return rewriteValuePPC64_OpHmul32(v) case OpHmul32u: - return rewriteValuePPC64_OpHmul32u(v, config) + return rewriteValuePPC64_OpHmul32u(v) case OpHmul64: - return rewriteValuePPC64_OpHmul64(v, config) + return rewriteValuePPC64_OpHmul64(v) case OpHmul64u: - return rewriteValuePPC64_OpHmul64u(v, config) + return rewriteValuePPC64_OpHmul64u(v) case OpInterCall: - return rewriteValuePPC64_OpInterCall(v, config) + return rewriteValuePPC64_OpInterCall(v) case OpIsInBounds: - return rewriteValuePPC64_OpIsInBounds(v, config) + return rewriteValuePPC64_OpIsInBounds(v) case OpIsNonNil: - return rewriteValuePPC64_OpIsNonNil(v, config) + return rewriteValuePPC64_OpIsNonNil(v) case OpIsSliceInBounds: - return rewriteValuePPC64_OpIsSliceInBounds(v, config) + return rewriteValuePPC64_OpIsSliceInBounds(v) case OpLeq16: - return rewriteValuePPC64_OpLeq16(v, config) + return rewriteValuePPC64_OpLeq16(v) case OpLeq16U: - return rewriteValuePPC64_OpLeq16U(v, config) + return rewriteValuePPC64_OpLeq16U(v) case OpLeq32: - return rewriteValuePPC64_OpLeq32(v, config) + return rewriteValuePPC64_OpLeq32(v) case OpLeq32F: - return rewriteValuePPC64_OpLeq32F(v, config) + return rewriteValuePPC64_OpLeq32F(v) case OpLeq32U: - return rewriteValuePPC64_OpLeq32U(v, config) + return rewriteValuePPC64_OpLeq32U(v) case OpLeq64: - return rewriteValuePPC64_OpLeq64(v, config) + return rewriteValuePPC64_OpLeq64(v) case OpLeq64F: - return rewriteValuePPC64_OpLeq64F(v, config) + return rewriteValuePPC64_OpLeq64F(v) case OpLeq64U: - return rewriteValuePPC64_OpLeq64U(v, config) + return rewriteValuePPC64_OpLeq64U(v) case OpLeq8: - return rewriteValuePPC64_OpLeq8(v, config) + return rewriteValuePPC64_OpLeq8(v) case OpLeq8U: - return rewriteValuePPC64_OpLeq8U(v, config) + return rewriteValuePPC64_OpLeq8U(v) case OpLess16: - return rewriteValuePPC64_OpLess16(v, config) + return rewriteValuePPC64_OpLess16(v) case OpLess16U: - return rewriteValuePPC64_OpLess16U(v, config) + return rewriteValuePPC64_OpLess16U(v) case OpLess32: - return rewriteValuePPC64_OpLess32(v, config) + return rewriteValuePPC64_OpLess32(v) case OpLess32F: - return rewriteValuePPC64_OpLess32F(v, config) + return rewriteValuePPC64_OpLess32F(v) case OpLess32U: - return rewriteValuePPC64_OpLess32U(v, config) + return rewriteValuePPC64_OpLess32U(v) case OpLess64: - return rewriteValuePPC64_OpLess64(v, config) + return rewriteValuePPC64_OpLess64(v) case OpLess64F: - return rewriteValuePPC64_OpLess64F(v, config) + return rewriteValuePPC64_OpLess64F(v) case OpLess64U: - return rewriteValuePPC64_OpLess64U(v, config) + return rewriteValuePPC64_OpLess64U(v) case OpLess8: - return rewriteValuePPC64_OpLess8(v, config) + return rewriteValuePPC64_OpLess8(v) case OpLess8U: - return rewriteValuePPC64_OpLess8U(v, config) + return rewriteValuePPC64_OpLess8U(v) case OpLoad: - return rewriteValuePPC64_OpLoad(v, config) + return rewriteValuePPC64_OpLoad(v) case OpLsh16x16: - return rewriteValuePPC64_OpLsh16x16(v, config) + return rewriteValuePPC64_OpLsh16x16(v) case OpLsh16x32: - return rewriteValuePPC64_OpLsh16x32(v, config) + return rewriteValuePPC64_OpLsh16x32(v) case OpLsh16x64: - return rewriteValuePPC64_OpLsh16x64(v, config) + return rewriteValuePPC64_OpLsh16x64(v) case OpLsh16x8: - return rewriteValuePPC64_OpLsh16x8(v, config) + return rewriteValuePPC64_OpLsh16x8(v) case OpLsh32x16: - return rewriteValuePPC64_OpLsh32x16(v, config) + return rewriteValuePPC64_OpLsh32x16(v) case OpLsh32x32: - return rewriteValuePPC64_OpLsh32x32(v, config) + return rewriteValuePPC64_OpLsh32x32(v) case OpLsh32x64: - return rewriteValuePPC64_OpLsh32x64(v, config) + return rewriteValuePPC64_OpLsh32x64(v) case OpLsh32x8: - return rewriteValuePPC64_OpLsh32x8(v, config) + return rewriteValuePPC64_OpLsh32x8(v) case OpLsh64x16: - return rewriteValuePPC64_OpLsh64x16(v, config) + return rewriteValuePPC64_OpLsh64x16(v) case OpLsh64x32: - return rewriteValuePPC64_OpLsh64x32(v, config) + return rewriteValuePPC64_OpLsh64x32(v) case OpLsh64x64: - return rewriteValuePPC64_OpLsh64x64(v, config) + return rewriteValuePPC64_OpLsh64x64(v) case OpLsh64x8: - return rewriteValuePPC64_OpLsh64x8(v, config) + return rewriteValuePPC64_OpLsh64x8(v) case OpLsh8x16: - return rewriteValuePPC64_OpLsh8x16(v, config) + return rewriteValuePPC64_OpLsh8x16(v) case OpLsh8x32: - return rewriteValuePPC64_OpLsh8x32(v, config) + return rewriteValuePPC64_OpLsh8x32(v) case OpLsh8x64: - return rewriteValuePPC64_OpLsh8x64(v, config) + return rewriteValuePPC64_OpLsh8x64(v) case OpLsh8x8: - return rewriteValuePPC64_OpLsh8x8(v, config) + return rewriteValuePPC64_OpLsh8x8(v) case OpMod16: - return rewriteValuePPC64_OpMod16(v, config) + return rewriteValuePPC64_OpMod16(v) case OpMod16u: - return rewriteValuePPC64_OpMod16u(v, config) + return rewriteValuePPC64_OpMod16u(v) case OpMod32: - return rewriteValuePPC64_OpMod32(v, config) + return rewriteValuePPC64_OpMod32(v) case OpMod32u: - return rewriteValuePPC64_OpMod32u(v, config) + return rewriteValuePPC64_OpMod32u(v) case OpMod64: - return rewriteValuePPC64_OpMod64(v, config) + return rewriteValuePPC64_OpMod64(v) case OpMod64u: - return rewriteValuePPC64_OpMod64u(v, config) + return rewriteValuePPC64_OpMod64u(v) case OpMod8: - return rewriteValuePPC64_OpMod8(v, config) + return rewriteValuePPC64_OpMod8(v) case OpMod8u: - return rewriteValuePPC64_OpMod8u(v, config) + return rewriteValuePPC64_OpMod8u(v) case OpMove: - return rewriteValuePPC64_OpMove(v, config) + return rewriteValuePPC64_OpMove(v) case OpMul16: - return rewriteValuePPC64_OpMul16(v, config) + return rewriteValuePPC64_OpMul16(v) case OpMul32: - return rewriteValuePPC64_OpMul32(v, config) + return rewriteValuePPC64_OpMul32(v) case OpMul32F: - return rewriteValuePPC64_OpMul32F(v, config) + return rewriteValuePPC64_OpMul32F(v) case OpMul64: - return rewriteValuePPC64_OpMul64(v, config) + return rewriteValuePPC64_OpMul64(v) case OpMul64F: - return rewriteValuePPC64_OpMul64F(v, config) + return rewriteValuePPC64_OpMul64F(v) case OpMul8: - return rewriteValuePPC64_OpMul8(v, config) + return rewriteValuePPC64_OpMul8(v) case OpNeg16: - return rewriteValuePPC64_OpNeg16(v, config) + return rewriteValuePPC64_OpNeg16(v) case OpNeg32: - return rewriteValuePPC64_OpNeg32(v, config) + return rewriteValuePPC64_OpNeg32(v) case OpNeg32F: - return rewriteValuePPC64_OpNeg32F(v, config) + return rewriteValuePPC64_OpNeg32F(v) case OpNeg64: - return rewriteValuePPC64_OpNeg64(v, config) + return rewriteValuePPC64_OpNeg64(v) case OpNeg64F: - return rewriteValuePPC64_OpNeg64F(v, config) + return rewriteValuePPC64_OpNeg64F(v) case OpNeg8: - return rewriteValuePPC64_OpNeg8(v, config) + return rewriteValuePPC64_OpNeg8(v) case OpNeq16: - return rewriteValuePPC64_OpNeq16(v, config) + return rewriteValuePPC64_OpNeq16(v) case OpNeq32: - return rewriteValuePPC64_OpNeq32(v, config) + return rewriteValuePPC64_OpNeq32(v) case OpNeq32F: - return rewriteValuePPC64_OpNeq32F(v, config) + return rewriteValuePPC64_OpNeq32F(v) case OpNeq64: - return rewriteValuePPC64_OpNeq64(v, config) + return rewriteValuePPC64_OpNeq64(v) case OpNeq64F: - return rewriteValuePPC64_OpNeq64F(v, config) + return rewriteValuePPC64_OpNeq64F(v) case OpNeq8: - return rewriteValuePPC64_OpNeq8(v, config) + return rewriteValuePPC64_OpNeq8(v) case OpNeqB: - return rewriteValuePPC64_OpNeqB(v, config) + return rewriteValuePPC64_OpNeqB(v) case OpNeqPtr: - return rewriteValuePPC64_OpNeqPtr(v, config) + return rewriteValuePPC64_OpNeqPtr(v) case OpNilCheck: - return rewriteValuePPC64_OpNilCheck(v, config) + return rewriteValuePPC64_OpNilCheck(v) case OpNot: - return rewriteValuePPC64_OpNot(v, config) + return rewriteValuePPC64_OpNot(v) case OpOffPtr: - return rewriteValuePPC64_OpOffPtr(v, config) + return rewriteValuePPC64_OpOffPtr(v) case OpOr16: - return rewriteValuePPC64_OpOr16(v, config) + return rewriteValuePPC64_OpOr16(v) case OpOr32: - return rewriteValuePPC64_OpOr32(v, config) + return rewriteValuePPC64_OpOr32(v) case OpOr64: - return rewriteValuePPC64_OpOr64(v, config) + return rewriteValuePPC64_OpOr64(v) case OpOr8: - return rewriteValuePPC64_OpOr8(v, config) + return rewriteValuePPC64_OpOr8(v) case OpOrB: - return rewriteValuePPC64_OpOrB(v, config) + return rewriteValuePPC64_OpOrB(v) case OpPPC64ADD: - return rewriteValuePPC64_OpPPC64ADD(v, config) + return rewriteValuePPC64_OpPPC64ADD(v) case OpPPC64ADDconst: - return rewriteValuePPC64_OpPPC64ADDconst(v, config) + return rewriteValuePPC64_OpPPC64ADDconst(v) case OpPPC64AND: - return rewriteValuePPC64_OpPPC64AND(v, config) + return rewriteValuePPC64_OpPPC64AND(v) case OpPPC64ANDconst: - return rewriteValuePPC64_OpPPC64ANDconst(v, config) + return rewriteValuePPC64_OpPPC64ANDconst(v) case OpPPC64CMP: - return rewriteValuePPC64_OpPPC64CMP(v, config) + return rewriteValuePPC64_OpPPC64CMP(v) case OpPPC64CMPU: - return rewriteValuePPC64_OpPPC64CMPU(v, config) + return rewriteValuePPC64_OpPPC64CMPU(v) case OpPPC64CMPUconst: - return rewriteValuePPC64_OpPPC64CMPUconst(v, config) + return rewriteValuePPC64_OpPPC64CMPUconst(v) case OpPPC64CMPW: - return rewriteValuePPC64_OpPPC64CMPW(v, config) + return rewriteValuePPC64_OpPPC64CMPW(v) case OpPPC64CMPWU: - return rewriteValuePPC64_OpPPC64CMPWU(v, config) + return rewriteValuePPC64_OpPPC64CMPWU(v) case OpPPC64CMPWUconst: - return rewriteValuePPC64_OpPPC64CMPWUconst(v, config) + return rewriteValuePPC64_OpPPC64CMPWUconst(v) case OpPPC64CMPWconst: - return rewriteValuePPC64_OpPPC64CMPWconst(v, config) + return rewriteValuePPC64_OpPPC64CMPWconst(v) case OpPPC64CMPconst: - return rewriteValuePPC64_OpPPC64CMPconst(v, config) + return rewriteValuePPC64_OpPPC64CMPconst(v) case OpPPC64Equal: - return rewriteValuePPC64_OpPPC64Equal(v, config) + return rewriteValuePPC64_OpPPC64Equal(v) case OpPPC64FMOVDload: - return rewriteValuePPC64_OpPPC64FMOVDload(v, config) + return rewriteValuePPC64_OpPPC64FMOVDload(v) case OpPPC64FMOVDstore: - return rewriteValuePPC64_OpPPC64FMOVDstore(v, config) + return rewriteValuePPC64_OpPPC64FMOVDstore(v) case OpPPC64FMOVSload: - return rewriteValuePPC64_OpPPC64FMOVSload(v, config) + return rewriteValuePPC64_OpPPC64FMOVSload(v) case OpPPC64FMOVSstore: - return rewriteValuePPC64_OpPPC64FMOVSstore(v, config) + return rewriteValuePPC64_OpPPC64FMOVSstore(v) case OpPPC64GreaterEqual: - return rewriteValuePPC64_OpPPC64GreaterEqual(v, config) + return rewriteValuePPC64_OpPPC64GreaterEqual(v) case OpPPC64GreaterThan: - return rewriteValuePPC64_OpPPC64GreaterThan(v, config) + return rewriteValuePPC64_OpPPC64GreaterThan(v) case OpPPC64LessEqual: - return rewriteValuePPC64_OpPPC64LessEqual(v, config) + return rewriteValuePPC64_OpPPC64LessEqual(v) case OpPPC64LessThan: - return rewriteValuePPC64_OpPPC64LessThan(v, config) + return rewriteValuePPC64_OpPPC64LessThan(v) case OpPPC64MOVBZload: - return rewriteValuePPC64_OpPPC64MOVBZload(v, config) + return rewriteValuePPC64_OpPPC64MOVBZload(v) case OpPPC64MOVBZreg: - return rewriteValuePPC64_OpPPC64MOVBZreg(v, config) + return rewriteValuePPC64_OpPPC64MOVBZreg(v) case OpPPC64MOVBreg: - return rewriteValuePPC64_OpPPC64MOVBreg(v, config) + return rewriteValuePPC64_OpPPC64MOVBreg(v) case OpPPC64MOVBstore: - return rewriteValuePPC64_OpPPC64MOVBstore(v, config) + return rewriteValuePPC64_OpPPC64MOVBstore(v) case OpPPC64MOVBstorezero: - return rewriteValuePPC64_OpPPC64MOVBstorezero(v, config) + return rewriteValuePPC64_OpPPC64MOVBstorezero(v) case OpPPC64MOVDload: - return rewriteValuePPC64_OpPPC64MOVDload(v, config) + return rewriteValuePPC64_OpPPC64MOVDload(v) case OpPPC64MOVDstore: - return rewriteValuePPC64_OpPPC64MOVDstore(v, config) + return rewriteValuePPC64_OpPPC64MOVDstore(v) case OpPPC64MOVDstorezero: - return rewriteValuePPC64_OpPPC64MOVDstorezero(v, config) + return rewriteValuePPC64_OpPPC64MOVDstorezero(v) case OpPPC64MOVHZload: - return rewriteValuePPC64_OpPPC64MOVHZload(v, config) + return rewriteValuePPC64_OpPPC64MOVHZload(v) case OpPPC64MOVHZreg: - return rewriteValuePPC64_OpPPC64MOVHZreg(v, config) + return rewriteValuePPC64_OpPPC64MOVHZreg(v) case OpPPC64MOVHload: - return rewriteValuePPC64_OpPPC64MOVHload(v, config) + return rewriteValuePPC64_OpPPC64MOVHload(v) case OpPPC64MOVHreg: - return rewriteValuePPC64_OpPPC64MOVHreg(v, config) + return rewriteValuePPC64_OpPPC64MOVHreg(v) case OpPPC64MOVHstore: - return rewriteValuePPC64_OpPPC64MOVHstore(v, config) + return rewriteValuePPC64_OpPPC64MOVHstore(v) case OpPPC64MOVHstorezero: - return rewriteValuePPC64_OpPPC64MOVHstorezero(v, config) + return rewriteValuePPC64_OpPPC64MOVHstorezero(v) case OpPPC64MOVWZload: - return rewriteValuePPC64_OpPPC64MOVWZload(v, config) + return rewriteValuePPC64_OpPPC64MOVWZload(v) case OpPPC64MOVWZreg: - return rewriteValuePPC64_OpPPC64MOVWZreg(v, config) + return rewriteValuePPC64_OpPPC64MOVWZreg(v) case OpPPC64MOVWload: - return rewriteValuePPC64_OpPPC64MOVWload(v, config) + return rewriteValuePPC64_OpPPC64MOVWload(v) case OpPPC64MOVWreg: - return rewriteValuePPC64_OpPPC64MOVWreg(v, config) + return rewriteValuePPC64_OpPPC64MOVWreg(v) case OpPPC64MOVWstore: - return rewriteValuePPC64_OpPPC64MOVWstore(v, config) + return rewriteValuePPC64_OpPPC64MOVWstore(v) case OpPPC64MOVWstorezero: - return rewriteValuePPC64_OpPPC64MOVWstorezero(v, config) + return rewriteValuePPC64_OpPPC64MOVWstorezero(v) case OpPPC64MaskIfNotCarry: - return rewriteValuePPC64_OpPPC64MaskIfNotCarry(v, config) + return rewriteValuePPC64_OpPPC64MaskIfNotCarry(v) case OpPPC64NotEqual: - return rewriteValuePPC64_OpPPC64NotEqual(v, config) + return rewriteValuePPC64_OpPPC64NotEqual(v) case OpPPC64OR: - return rewriteValuePPC64_OpPPC64OR(v, config) + return rewriteValuePPC64_OpPPC64OR(v) case OpPPC64ORN: - return rewriteValuePPC64_OpPPC64ORN(v, config) + return rewriteValuePPC64_OpPPC64ORN(v) case OpPPC64ORconst: - return rewriteValuePPC64_OpPPC64ORconst(v, config) + return rewriteValuePPC64_OpPPC64ORconst(v) case OpPPC64SUB: - return rewriteValuePPC64_OpPPC64SUB(v, config) + return rewriteValuePPC64_OpPPC64SUB(v) case OpPPC64XOR: - return rewriteValuePPC64_OpPPC64XOR(v, config) + return rewriteValuePPC64_OpPPC64XOR(v) case OpPPC64XORconst: - return rewriteValuePPC64_OpPPC64XORconst(v, config) + return rewriteValuePPC64_OpPPC64XORconst(v) case OpRound32F: - return rewriteValuePPC64_OpRound32F(v, config) + return rewriteValuePPC64_OpRound32F(v) case OpRound64F: - return rewriteValuePPC64_OpRound64F(v, config) + return rewriteValuePPC64_OpRound64F(v) case OpRsh16Ux16: - return rewriteValuePPC64_OpRsh16Ux16(v, config) + return rewriteValuePPC64_OpRsh16Ux16(v) case OpRsh16Ux32: - return rewriteValuePPC64_OpRsh16Ux32(v, config) + return rewriteValuePPC64_OpRsh16Ux32(v) case OpRsh16Ux64: - return rewriteValuePPC64_OpRsh16Ux64(v, config) + return rewriteValuePPC64_OpRsh16Ux64(v) case OpRsh16Ux8: - return rewriteValuePPC64_OpRsh16Ux8(v, config) + return rewriteValuePPC64_OpRsh16Ux8(v) case OpRsh16x16: - return rewriteValuePPC64_OpRsh16x16(v, config) + return rewriteValuePPC64_OpRsh16x16(v) case OpRsh16x32: - return rewriteValuePPC64_OpRsh16x32(v, config) + return rewriteValuePPC64_OpRsh16x32(v) case OpRsh16x64: - return rewriteValuePPC64_OpRsh16x64(v, config) + return rewriteValuePPC64_OpRsh16x64(v) case OpRsh16x8: - return rewriteValuePPC64_OpRsh16x8(v, config) + return rewriteValuePPC64_OpRsh16x8(v) case OpRsh32Ux16: - return rewriteValuePPC64_OpRsh32Ux16(v, config) + return rewriteValuePPC64_OpRsh32Ux16(v) case OpRsh32Ux32: - return rewriteValuePPC64_OpRsh32Ux32(v, config) + return rewriteValuePPC64_OpRsh32Ux32(v) case OpRsh32Ux64: - return rewriteValuePPC64_OpRsh32Ux64(v, config) + return rewriteValuePPC64_OpRsh32Ux64(v) case OpRsh32Ux8: - return rewriteValuePPC64_OpRsh32Ux8(v, config) + return rewriteValuePPC64_OpRsh32Ux8(v) case OpRsh32x16: - return rewriteValuePPC64_OpRsh32x16(v, config) + return rewriteValuePPC64_OpRsh32x16(v) case OpRsh32x32: - return rewriteValuePPC64_OpRsh32x32(v, config) + return rewriteValuePPC64_OpRsh32x32(v) case OpRsh32x64: - return rewriteValuePPC64_OpRsh32x64(v, config) + return rewriteValuePPC64_OpRsh32x64(v) case OpRsh32x8: - return rewriteValuePPC64_OpRsh32x8(v, config) + return rewriteValuePPC64_OpRsh32x8(v) case OpRsh64Ux16: - return rewriteValuePPC64_OpRsh64Ux16(v, config) + return rewriteValuePPC64_OpRsh64Ux16(v) case OpRsh64Ux32: - return rewriteValuePPC64_OpRsh64Ux32(v, config) + return rewriteValuePPC64_OpRsh64Ux32(v) case OpRsh64Ux64: - return rewriteValuePPC64_OpRsh64Ux64(v, config) + return rewriteValuePPC64_OpRsh64Ux64(v) case OpRsh64Ux8: - return rewriteValuePPC64_OpRsh64Ux8(v, config) + return rewriteValuePPC64_OpRsh64Ux8(v) case OpRsh64x16: - return rewriteValuePPC64_OpRsh64x16(v, config) + return rewriteValuePPC64_OpRsh64x16(v) case OpRsh64x32: - return rewriteValuePPC64_OpRsh64x32(v, config) + return rewriteValuePPC64_OpRsh64x32(v) case OpRsh64x64: - return rewriteValuePPC64_OpRsh64x64(v, config) + return rewriteValuePPC64_OpRsh64x64(v) case OpRsh64x8: - return rewriteValuePPC64_OpRsh64x8(v, config) + return rewriteValuePPC64_OpRsh64x8(v) case OpRsh8Ux16: - return rewriteValuePPC64_OpRsh8Ux16(v, config) + return rewriteValuePPC64_OpRsh8Ux16(v) case OpRsh8Ux32: - return rewriteValuePPC64_OpRsh8Ux32(v, config) + return rewriteValuePPC64_OpRsh8Ux32(v) case OpRsh8Ux64: - return rewriteValuePPC64_OpRsh8Ux64(v, config) + return rewriteValuePPC64_OpRsh8Ux64(v) case OpRsh8Ux8: - return rewriteValuePPC64_OpRsh8Ux8(v, config) + return rewriteValuePPC64_OpRsh8Ux8(v) case OpRsh8x16: - return rewriteValuePPC64_OpRsh8x16(v, config) + return rewriteValuePPC64_OpRsh8x16(v) case OpRsh8x32: - return rewriteValuePPC64_OpRsh8x32(v, config) + return rewriteValuePPC64_OpRsh8x32(v) case OpRsh8x64: - return rewriteValuePPC64_OpRsh8x64(v, config) + return rewriteValuePPC64_OpRsh8x64(v) case OpRsh8x8: - return rewriteValuePPC64_OpRsh8x8(v, config) + return rewriteValuePPC64_OpRsh8x8(v) case OpSignExt16to32: - return rewriteValuePPC64_OpSignExt16to32(v, config) + return rewriteValuePPC64_OpSignExt16to32(v) case OpSignExt16to64: - return rewriteValuePPC64_OpSignExt16to64(v, config) + return rewriteValuePPC64_OpSignExt16to64(v) case OpSignExt32to64: - return rewriteValuePPC64_OpSignExt32to64(v, config) + return rewriteValuePPC64_OpSignExt32to64(v) case OpSignExt8to16: - return rewriteValuePPC64_OpSignExt8to16(v, config) + return rewriteValuePPC64_OpSignExt8to16(v) case OpSignExt8to32: - return rewriteValuePPC64_OpSignExt8to32(v, config) + return rewriteValuePPC64_OpSignExt8to32(v) case OpSignExt8to64: - return rewriteValuePPC64_OpSignExt8to64(v, config) + return rewriteValuePPC64_OpSignExt8to64(v) case OpSlicemask: - return rewriteValuePPC64_OpSlicemask(v, config) + return rewriteValuePPC64_OpSlicemask(v) case OpSqrt: - return rewriteValuePPC64_OpSqrt(v, config) + return rewriteValuePPC64_OpSqrt(v) case OpStaticCall: - return rewriteValuePPC64_OpStaticCall(v, config) + return rewriteValuePPC64_OpStaticCall(v) case OpStore: - return rewriteValuePPC64_OpStore(v, config) + return rewriteValuePPC64_OpStore(v) case OpSub16: - return rewriteValuePPC64_OpSub16(v, config) + return rewriteValuePPC64_OpSub16(v) case OpSub32: - return rewriteValuePPC64_OpSub32(v, config) + return rewriteValuePPC64_OpSub32(v) case OpSub32F: - return rewriteValuePPC64_OpSub32F(v, config) + return rewriteValuePPC64_OpSub32F(v) case OpSub64: - return rewriteValuePPC64_OpSub64(v, config) + return rewriteValuePPC64_OpSub64(v) case OpSub64F: - return rewriteValuePPC64_OpSub64F(v, config) + return rewriteValuePPC64_OpSub64F(v) case OpSub8: - return rewriteValuePPC64_OpSub8(v, config) + return rewriteValuePPC64_OpSub8(v) case OpSubPtr: - return rewriteValuePPC64_OpSubPtr(v, config) + return rewriteValuePPC64_OpSubPtr(v) case OpTrunc16to8: - return rewriteValuePPC64_OpTrunc16to8(v, config) + return rewriteValuePPC64_OpTrunc16to8(v) case OpTrunc32to16: - return rewriteValuePPC64_OpTrunc32to16(v, config) + return rewriteValuePPC64_OpTrunc32to16(v) case OpTrunc32to8: - return rewriteValuePPC64_OpTrunc32to8(v, config) + return rewriteValuePPC64_OpTrunc32to8(v) case OpTrunc64to16: - return rewriteValuePPC64_OpTrunc64to16(v, config) + return rewriteValuePPC64_OpTrunc64to16(v) case OpTrunc64to32: - return rewriteValuePPC64_OpTrunc64to32(v, config) + return rewriteValuePPC64_OpTrunc64to32(v) case OpTrunc64to8: - return rewriteValuePPC64_OpTrunc64to8(v, config) + return rewriteValuePPC64_OpTrunc64to8(v) case OpXor16: - return rewriteValuePPC64_OpXor16(v, config) + return rewriteValuePPC64_OpXor16(v) case OpXor32: - return rewriteValuePPC64_OpXor32(v, config) + return rewriteValuePPC64_OpXor32(v) case OpXor64: - return rewriteValuePPC64_OpXor64(v, config) + return rewriteValuePPC64_OpXor64(v) case OpXor8: - return rewriteValuePPC64_OpXor8(v, config) + return rewriteValuePPC64_OpXor8(v) case OpZero: - return rewriteValuePPC64_OpZero(v, config) + return rewriteValuePPC64_OpZero(v) case OpZeroExt16to32: - return rewriteValuePPC64_OpZeroExt16to32(v, config) + return rewriteValuePPC64_OpZeroExt16to32(v) case OpZeroExt16to64: - return rewriteValuePPC64_OpZeroExt16to64(v, config) + return rewriteValuePPC64_OpZeroExt16to64(v) case OpZeroExt32to64: - return rewriteValuePPC64_OpZeroExt32to64(v, config) + return rewriteValuePPC64_OpZeroExt32to64(v) case OpZeroExt8to16: - return rewriteValuePPC64_OpZeroExt8to16(v, config) + return rewriteValuePPC64_OpZeroExt8to16(v) case OpZeroExt8to32: - return rewriteValuePPC64_OpZeroExt8to32(v, config) + return rewriteValuePPC64_OpZeroExt8to32(v) case OpZeroExt8to64: - return rewriteValuePPC64_OpZeroExt8to64(v, config) + return rewriteValuePPC64_OpZeroExt8to64(v) } return false } -func rewriteValuePPC64_OpAdd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAdd16(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADD x y) @@ -604,9 +602,7 @@ func rewriteValuePPC64_OpAdd16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAdd32(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADD x y) @@ -619,9 +615,7 @@ func rewriteValuePPC64_OpAdd32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAdd32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAdd32F(v *Value) bool { // match: (Add32F x y) // cond: // result: (FADDS x y) @@ -634,9 +628,7 @@ func rewriteValuePPC64_OpAdd32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAdd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAdd64(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADD x y) @@ -649,9 +641,7 @@ func rewriteValuePPC64_OpAdd64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAdd64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAdd64F(v *Value) bool { // match: (Add64F x y) // cond: // result: (FADD x y) @@ -664,9 +654,7 @@ func rewriteValuePPC64_OpAdd64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAdd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAdd8(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADD x y) @@ -679,9 +667,7 @@ func rewriteValuePPC64_OpAdd8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAddPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAddPtr(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -694,9 +680,7 @@ func rewriteValuePPC64_OpAddPtr(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAddr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAddr(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVDaddr {sym} base) @@ -709,9 +693,7 @@ func rewriteValuePPC64_OpAddr(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAnd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAnd16(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -724,9 +706,7 @@ func rewriteValuePPC64_OpAnd16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAnd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAnd32(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -739,9 +719,7 @@ func rewriteValuePPC64_OpAnd32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAnd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAnd64(v *Value) bool { // match: (And64 x y) // cond: // result: (AND x y) @@ -754,9 +732,7 @@ func rewriteValuePPC64_OpAnd64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAnd8(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -769,9 +745,7 @@ func rewriteValuePPC64_OpAnd8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAndB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAndB(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -784,9 +758,7 @@ func rewriteValuePPC64_OpAndB(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicAdd32(v *Value) bool { // match: (AtomicAdd32 ptr val mem) // cond: // result: (LoweredAtomicAdd32 ptr val mem) @@ -801,9 +773,7 @@ func rewriteValuePPC64_OpAtomicAdd32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicAdd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicAdd64(v *Value) bool { // match: (AtomicAdd64 ptr val mem) // cond: // result: (LoweredAtomicAdd64 ptr val mem) @@ -818,9 +788,7 @@ func rewriteValuePPC64_OpAtomicAdd64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicAnd8(v *Value) bool { // match: (AtomicAnd8 ptr val mem) // cond: // result: (LoweredAtomicAnd8 ptr val mem) @@ -835,9 +803,7 @@ func rewriteValuePPC64_OpAtomicAnd8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (LoweredAtomicCas32 ptr old new_ mem) @@ -854,9 +820,7 @@ func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value) bool { // match: (AtomicCompareAndSwap64 ptr old new_ mem) // cond: // result: (LoweredAtomicCas64 ptr old new_ mem) @@ -873,9 +837,7 @@ func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicExchange32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicExchange32(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (LoweredAtomicExchange32 ptr val mem) @@ -890,9 +852,7 @@ func rewriteValuePPC64_OpAtomicExchange32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicExchange64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicExchange64(v *Value) bool { // match: (AtomicExchange64 ptr val mem) // cond: // result: (LoweredAtomicExchange64 ptr val mem) @@ -907,9 +867,7 @@ func rewriteValuePPC64_OpAtomicExchange64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicLoad32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicLoad32(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (LoweredAtomicLoad32 ptr mem) @@ -922,9 +880,7 @@ func rewriteValuePPC64_OpAtomicLoad32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicLoad64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicLoad64(v *Value) bool { // match: (AtomicLoad64 ptr mem) // cond: // result: (LoweredAtomicLoad64 ptr mem) @@ -937,9 +893,7 @@ func rewriteValuePPC64_OpAtomicLoad64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicLoadPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicLoadPtr(v *Value) bool { // match: (AtomicLoadPtr ptr mem) // cond: // result: (LoweredAtomicLoadPtr ptr mem) @@ -952,9 +906,7 @@ func rewriteValuePPC64_OpAtomicLoadPtr(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicOr8(v *Value) bool { // match: (AtomicOr8 ptr val mem) // cond: // result: (LoweredAtomicOr8 ptr val mem) @@ -969,9 +921,7 @@ func rewriteValuePPC64_OpAtomicOr8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicStore32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicStore32(v *Value) bool { // match: (AtomicStore32 ptr val mem) // cond: // result: (LoweredAtomicStore32 ptr val mem) @@ -986,9 +936,7 @@ func rewriteValuePPC64_OpAtomicStore32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAtomicStore64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpAtomicStore64(v *Value) bool { // match: (AtomicStore64 ptr val mem) // cond: // result: (LoweredAtomicStore64 ptr val mem) @@ -1003,7 +951,7 @@ func rewriteValuePPC64_OpAtomicStore64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpAvg64u(v *Value, config *Config) bool { +func rewriteValuePPC64_OpAvg64u(v *Value) bool { b := v.Block _ = b // match: (Avg64u <t> x y) @@ -1025,9 +973,7 @@ func rewriteValuePPC64_OpAvg64u(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpClosureCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpClosureCall(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -1044,9 +990,7 @@ func rewriteValuePPC64_OpClosureCall(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpCom16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpCom16(v *Value) bool { // match: (Com16 x) // cond: // result: (NOR x x) @@ -1058,9 +1002,7 @@ func rewriteValuePPC64_OpCom16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpCom32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpCom32(v *Value) bool { // match: (Com32 x) // cond: // result: (NOR x x) @@ -1072,9 +1014,7 @@ func rewriteValuePPC64_OpCom32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpCom64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpCom64(v *Value) bool { // match: (Com64 x) // cond: // result: (NOR x x) @@ -1086,9 +1026,7 @@ func rewriteValuePPC64_OpCom64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpCom8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpCom8(v *Value) bool { // match: (Com8 x) // cond: // result: (NOR x x) @@ -1100,9 +1038,7 @@ func rewriteValuePPC64_OpCom8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpConst16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpConst16(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVDconst [val]) @@ -1113,9 +1049,7 @@ func rewriteValuePPC64_OpConst16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpConst32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpConst32(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVDconst [val]) @@ -1126,9 +1060,7 @@ func rewriteValuePPC64_OpConst32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpConst32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpConst32F(v *Value) bool { // match: (Const32F [val]) // cond: // result: (FMOVSconst [val]) @@ -1139,9 +1071,7 @@ func rewriteValuePPC64_OpConst32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpConst64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpConst64(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVDconst [val]) @@ -1152,9 +1082,7 @@ func rewriteValuePPC64_OpConst64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpConst64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpConst64F(v *Value) bool { // match: (Const64F [val]) // cond: // result: (FMOVDconst [val]) @@ -1165,9 +1093,7 @@ func rewriteValuePPC64_OpConst64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpConst8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpConst8(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVDconst [val]) @@ -1178,9 +1104,7 @@ func rewriteValuePPC64_OpConst8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpConstBool(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpConstBool(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVDconst [b]) @@ -1191,9 +1115,7 @@ func rewriteValuePPC64_OpConstBool(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpConstNil(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpConstNil(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVDconst [0]) @@ -1203,9 +1125,7 @@ func rewriteValuePPC64_OpConstNil(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpConvert(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpConvert(v *Value) bool { // match: (Convert <t> x mem) // cond: // result: (MOVDconvert <t> x mem) @@ -1220,39 +1140,45 @@ func rewriteValuePPC64_OpConvert(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpCvt32Fto32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpCvt32Fto32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Cvt32Fto32 x) // cond: // result: (Xf2i64 (FCTIWZ x)) for { x := v.Args[0] v.reset(OpPPC64Xf2i64) - v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, config.fe.TypeFloat64()) + v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, fe.TypeFloat64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpCvt32Fto64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpCvt32Fto64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Cvt32Fto64 x) // cond: // result: (Xf2i64 (FCTIDZ x)) for { x := v.Args[0] v.reset(OpPPC64Xf2i64) - v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, config.fe.TypeFloat64()) + v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, fe.TypeFloat64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpCvt32Fto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpCvt32Fto64F(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: x @@ -1264,18 +1190,22 @@ func rewriteValuePPC64_OpCvt32Fto64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpCvt32to32F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpCvt32to32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Cvt32to32F x) // cond: // result: (FRSP (FCFID (Xi2f64 (SignExt32to64 x)))) for { x := v.Args[0] v.reset(OpPPC64FRSP) - v0 := b.NewValue0(v.Pos, OpPPC64FCFID, config.fe.TypeFloat64()) - v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, config.fe.TypeFloat64()) - v2 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64FCFID, fe.TypeFloat64()) + v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, fe.TypeFloat64()) + v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v2.AddArg(x) v1.AddArg(v2) v0.AddArg(v1) @@ -1283,41 +1213,47 @@ func rewriteValuePPC64_OpCvt32to32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpCvt32to64F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpCvt32to64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Cvt32to64F x) // cond: // result: (FCFID (Xi2f64 (SignExt32to64 x))) for { x := v.Args[0] v.reset(OpPPC64FCFID) - v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, config.fe.TypeFloat64()) - v1 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, fe.TypeFloat64()) + v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpCvt64Fto32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpCvt64Fto32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Cvt64Fto32 x) // cond: // result: (Xf2i64 (FCTIWZ x)) for { x := v.Args[0] v.reset(OpPPC64Xf2i64) - v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, config.fe.TypeFloat64()) + v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, fe.TypeFloat64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpCvt64Fto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpCvt64Fto32F(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (FRSP x) @@ -1328,56 +1264,72 @@ func rewriteValuePPC64_OpCvt64Fto32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpCvt64Fto64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpCvt64Fto64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Cvt64Fto64 x) // cond: // result: (Xf2i64 (FCTIDZ x)) for { x := v.Args[0] v.reset(OpPPC64Xf2i64) - v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, config.fe.TypeFloat64()) + v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, fe.TypeFloat64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpCvt64to32F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpCvt64to32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Cvt64to32F x) // cond: // result: (FRSP (FCFID (Xi2f64 x))) for { x := v.Args[0] v.reset(OpPPC64FRSP) - v0 := b.NewValue0(v.Pos, OpPPC64FCFID, config.fe.TypeFloat64()) - v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, config.fe.TypeFloat64()) + v0 := b.NewValue0(v.Pos, OpPPC64FCFID, fe.TypeFloat64()) + v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, fe.TypeFloat64()) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpCvt64to64F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpCvt64to64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Cvt64to64F x) // cond: // result: (FCFID (Xi2f64 x)) for { x := v.Args[0] v.reset(OpPPC64FCFID) - v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, config.fe.TypeFloat64()) + v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, fe.TypeFloat64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpDiv16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpDiv16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16 x y) // cond: // result: (DIVW (SignExt16to32 x) (SignExt16to32 y)) @@ -1385,18 +1337,22 @@ func rewriteValuePPC64_OpDiv16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64DIVW) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuePPC64_OpDiv16u(v *Value, config *Config) bool { +func rewriteValuePPC64_OpDiv16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16u x y) // cond: // result: (DIVWU (ZeroExt16to32 x) (ZeroExt16to32 y)) @@ -1404,18 +1360,16 @@ func rewriteValuePPC64_OpDiv16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64DIVWU) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuePPC64_OpDiv32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpDiv32(v *Value) bool { // match: (Div32 x y) // cond: // result: (DIVW x y) @@ -1428,9 +1382,7 @@ func rewriteValuePPC64_OpDiv32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpDiv32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpDiv32F(v *Value) bool { // match: (Div32F x y) // cond: // result: (FDIVS x y) @@ -1443,9 +1395,7 @@ func rewriteValuePPC64_OpDiv32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpDiv32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpDiv32u(v *Value) bool { // match: (Div32u x y) // cond: // result: (DIVWU x y) @@ -1458,9 +1408,7 @@ func rewriteValuePPC64_OpDiv32u(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpDiv64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpDiv64(v *Value) bool { // match: (Div64 x y) // cond: // result: (DIVD x y) @@ -1473,9 +1421,7 @@ func rewriteValuePPC64_OpDiv64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpDiv64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpDiv64F(v *Value) bool { // match: (Div64F x y) // cond: // result: (FDIV x y) @@ -1488,9 +1434,7 @@ func rewriteValuePPC64_OpDiv64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpDiv64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpDiv64u(v *Value) bool { // match: (Div64u x y) // cond: // result: (DIVDU x y) @@ -1503,9 +1447,13 @@ func rewriteValuePPC64_OpDiv64u(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpDiv8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpDiv8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8 x y) // cond: // result: (DIVW (SignExt8to32 x) (SignExt8to32 y)) @@ -1513,18 +1461,22 @@ func rewriteValuePPC64_OpDiv8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64DIVW) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuePPC64_OpDiv8u(v *Value, config *Config) bool { +func rewriteValuePPC64_OpDiv8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8u x y) // cond: // result: (DIVWU (ZeroExt8to32 x) (ZeroExt8to32 y)) @@ -1532,18 +1484,22 @@ func rewriteValuePPC64_OpDiv8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64DIVWU) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuePPC64_OpEq16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpEq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq16 x y) // cond: isSigned(x.Type) && isSigned(y.Type) // result: (Equal (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -1555,10 +1511,10 @@ func rewriteValuePPC64_OpEq16(v *Value, config *Config) bool { } v.reset(OpPPC64Equal) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -1572,17 +1528,17 @@ func rewriteValuePPC64_OpEq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64Equal) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpEq32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpEq32(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -1599,7 +1555,7 @@ func rewriteValuePPC64_OpEq32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpEq32F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpEq32F(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -1616,7 +1572,7 @@ func rewriteValuePPC64_OpEq32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpEq64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpEq64(v *Value) bool { b := v.Block _ = b // match: (Eq64 x y) @@ -1633,7 +1589,7 @@ func rewriteValuePPC64_OpEq64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpEq64F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpEq64F(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -1650,9 +1606,13 @@ func rewriteValuePPC64_OpEq64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpEq8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpEq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq8 x y) // cond: isSigned(x.Type) && isSigned(y.Type) // result: (Equal (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -1664,10 +1624,10 @@ func rewriteValuePPC64_OpEq8(v *Value, config *Config) bool { } v.reset(OpPPC64Equal) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -1681,19 +1641,23 @@ func rewriteValuePPC64_OpEq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64Equal) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpEqB(v *Value, config *Config) bool { +func rewriteValuePPC64_OpEqB(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqB x y) // cond: // result: (ANDconst [1] (EQV x y)) @@ -1702,14 +1666,14 @@ func rewriteValuePPC64_OpEqB(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64ANDconst) v.AuxInt = 1 - v0 := b.NewValue0(v.Pos, OpPPC64EQV, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64EQV, fe.TypeInt64()) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpEqPtr(v *Value, config *Config) bool { +func rewriteValuePPC64_OpEqPtr(v *Value) bool { b := v.Block _ = b // match: (EqPtr x y) @@ -1726,9 +1690,13 @@ func rewriteValuePPC64_OpEqPtr(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGeq16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16 x y) // cond: // result: (GreaterEqual (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -1737,19 +1705,23 @@ func rewriteValuePPC64_OpGeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64GreaterEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpGeq16U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16U x y) // cond: // result: (GreaterEqual (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -1758,17 +1730,17 @@ func rewriteValuePPC64_OpGeq16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64GreaterEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpGeq32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq32(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -1785,7 +1757,7 @@ func rewriteValuePPC64_OpGeq32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGeq32F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq32F(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -1802,7 +1774,7 @@ func rewriteValuePPC64_OpGeq32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGeq32U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq32U(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -1819,7 +1791,7 @@ func rewriteValuePPC64_OpGeq32U(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGeq64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq64(v *Value) bool { b := v.Block _ = b // match: (Geq64 x y) @@ -1836,7 +1808,7 @@ func rewriteValuePPC64_OpGeq64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGeq64F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq64F(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -1853,7 +1825,7 @@ func rewriteValuePPC64_OpGeq64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGeq64U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq64U(v *Value) bool { b := v.Block _ = b // match: (Geq64U x y) @@ -1870,9 +1842,13 @@ func rewriteValuePPC64_OpGeq64U(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGeq8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8 x y) // cond: // result: (GreaterEqual (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -1881,19 +1857,23 @@ func rewriteValuePPC64_OpGeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64GreaterEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpGeq8U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8U x y) // cond: // result: (GreaterEqual (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -1902,19 +1882,17 @@ func rewriteValuePPC64_OpGeq8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64GreaterEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpGetClosurePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -1923,9 +1901,13 @@ func rewriteValuePPC64_OpGetClosurePtr(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGreater16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16 x y) // cond: // result: (GreaterThan (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -1934,19 +1916,23 @@ func rewriteValuePPC64_OpGreater16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64GreaterThan) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpGreater16U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16U x y) // cond: // result: (GreaterThan (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -1955,17 +1941,17 @@ func rewriteValuePPC64_OpGreater16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64GreaterThan) v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpGreater32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater32(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -1982,7 +1968,7 @@ func rewriteValuePPC64_OpGreater32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGreater32F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater32F(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -1999,7 +1985,7 @@ func rewriteValuePPC64_OpGreater32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGreater32U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater32U(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -2016,7 +2002,7 @@ func rewriteValuePPC64_OpGreater32U(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGreater64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater64(v *Value) bool { b := v.Block _ = b // match: (Greater64 x y) @@ -2033,7 +2019,7 @@ func rewriteValuePPC64_OpGreater64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGreater64F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater64F(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -2050,7 +2036,7 @@ func rewriteValuePPC64_OpGreater64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGreater64U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater64U(v *Value) bool { b := v.Block _ = b // match: (Greater64U x y) @@ -2067,9 +2053,13 @@ func rewriteValuePPC64_OpGreater64U(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpGreater8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8 x y) // cond: // result: (GreaterThan (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -2078,19 +2068,23 @@ func rewriteValuePPC64_OpGreater8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64GreaterThan) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpGreater8U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpGreater8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8U x y) // cond: // result: (GreaterThan (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -2099,19 +2093,17 @@ func rewriteValuePPC64_OpGreater8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64GreaterThan) v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpHmul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpHmul32(v *Value) bool { // match: (Hmul32 x y) // cond: // result: (MULHW x y) @@ -2124,9 +2116,7 @@ func rewriteValuePPC64_OpHmul32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpHmul32u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpHmul32u(v *Value) bool { // match: (Hmul32u x y) // cond: // result: (MULHWU x y) @@ -2139,9 +2129,7 @@ func rewriteValuePPC64_OpHmul32u(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpHmul64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpHmul64(v *Value) bool { // match: (Hmul64 x y) // cond: // result: (MULHD x y) @@ -2154,9 +2142,7 @@ func rewriteValuePPC64_OpHmul64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpHmul64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpHmul64u(v *Value) bool { // match: (Hmul64u x y) // cond: // result: (MULHDU x y) @@ -2169,9 +2155,7 @@ func rewriteValuePPC64_OpHmul64u(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpInterCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpInterCall(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -2186,7 +2170,7 @@ func rewriteValuePPC64_OpInterCall(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpIsInBounds(v *Value, config *Config) bool { +func rewriteValuePPC64_OpIsInBounds(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -2203,7 +2187,7 @@ func rewriteValuePPC64_OpIsInBounds(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpIsNonNil(v *Value, config *Config) bool { +func rewriteValuePPC64_OpIsNonNil(v *Value) bool { b := v.Block _ = b // match: (IsNonNil ptr) @@ -2219,7 +2203,7 @@ func rewriteValuePPC64_OpIsNonNil(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpIsSliceInBounds(v *Value, config *Config) bool { +func rewriteValuePPC64_OpIsSliceInBounds(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -2236,9 +2220,13 @@ func rewriteValuePPC64_OpIsSliceInBounds(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLeq16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16 x y) // cond: // result: (LessEqual (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -2247,19 +2235,23 @@ func rewriteValuePPC64_OpLeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64LessEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpLeq16U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16U x y) // cond: // result: (LessEqual (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -2268,17 +2260,17 @@ func rewriteValuePPC64_OpLeq16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64LessEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpLeq32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq32(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -2295,7 +2287,7 @@ func rewriteValuePPC64_OpLeq32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLeq32F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq32F(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -2312,7 +2304,7 @@ func rewriteValuePPC64_OpLeq32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLeq32U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq32U(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -2329,7 +2321,7 @@ func rewriteValuePPC64_OpLeq32U(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLeq64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq64(v *Value) bool { b := v.Block _ = b // match: (Leq64 x y) @@ -2346,7 +2338,7 @@ func rewriteValuePPC64_OpLeq64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLeq64F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq64F(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -2363,7 +2355,7 @@ func rewriteValuePPC64_OpLeq64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLeq64U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq64U(v *Value) bool { b := v.Block _ = b // match: (Leq64U x y) @@ -2380,9 +2372,13 @@ func rewriteValuePPC64_OpLeq64U(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLeq8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8 x y) // cond: // result: (LessEqual (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -2391,19 +2387,23 @@ func rewriteValuePPC64_OpLeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64LessEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpLeq8U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8U x y) // cond: // result: (LessEqual (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -2412,19 +2412,23 @@ func rewriteValuePPC64_OpLeq8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64LessEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpLess16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16 x y) // cond: // result: (LessThan (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -2433,19 +2437,23 @@ func rewriteValuePPC64_OpLess16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64LessThan) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpLess16U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16U x y) // cond: // result: (LessThan (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y))) @@ -2454,17 +2462,17 @@ func rewriteValuePPC64_OpLess16U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64LessThan) v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpLess32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess32(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -2481,7 +2489,7 @@ func rewriteValuePPC64_OpLess32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLess32F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess32F(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -2498,7 +2506,7 @@ func rewriteValuePPC64_OpLess32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLess32U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess32U(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -2515,7 +2523,7 @@ func rewriteValuePPC64_OpLess32U(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLess64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess64(v *Value) bool { b := v.Block _ = b // match: (Less64 x y) @@ -2532,7 +2540,7 @@ func rewriteValuePPC64_OpLess64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLess64F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess64F(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -2549,7 +2557,7 @@ func rewriteValuePPC64_OpLess64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLess64U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess64U(v *Value) bool { b := v.Block _ = b // match: (Less64U x y) @@ -2566,9 +2574,13 @@ func rewriteValuePPC64_OpLess64U(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLess8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8 x y) // cond: // result: (LessThan (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -2577,19 +2589,23 @@ func rewriteValuePPC64_OpLess8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64LessThan) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpLess8U(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLess8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8U x y) // cond: // result: (LessThan (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y))) @@ -2598,19 +2614,23 @@ func rewriteValuePPC64_OpLess8U(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64LessThan) v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpLoad(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLoad(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Load <t> ptr mem) // cond: (is64BitInt(t) || isPtr(t)) // result: (MOVDload ptr mem) @@ -2712,7 +2732,7 @@ func rewriteValuePPC64_OpLoad(v *Value, config *Config) bool { break } v.reset(OpPPC64MOVBreg) - v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) @@ -2765,23 +2785,27 @@ func rewriteValuePPC64_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpLsh16x16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x16 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -16 - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -2790,9 +2814,13 @@ func rewriteValuePPC64_OpLsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh16x32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x32 x (Const64 [c])) // cond: uint32(c) < 16 // result: (SLWconst x [c]) @@ -2831,18 +2859,18 @@ func rewriteValuePPC64_OpLsh16x32(v *Value, config *Config) bool { } // match: (Lsh16x32 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -16 - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -2851,9 +2879,13 @@ func rewriteValuePPC64_OpLsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh16x64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SLWconst x [c]) @@ -2908,15 +2940,15 @@ func rewriteValuePPC64_OpLsh16x64(v *Value, config *Config) bool { } // match: (Lsh16x64 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -16 v2.AddArg(y) @@ -2926,23 +2958,27 @@ func rewriteValuePPC64_OpLsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh16x8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x8 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -16 - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -2951,23 +2987,27 @@ func rewriteValuePPC64_OpLsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh32x16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x16 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -2976,9 +3016,13 @@ func rewriteValuePPC64_OpLsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh32x32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh32x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x32 x (Const64 [c])) // cond: uint32(c) < 32 // result: (SLWconst x [c]) @@ -3017,18 +3061,18 @@ func rewriteValuePPC64_OpLsh32x32(v *Value, config *Config) bool { } // match: (Lsh32x32 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3037,9 +3081,13 @@ func rewriteValuePPC64_OpLsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh32x64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh32x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SLWconst x [c]) @@ -3094,15 +3142,15 @@ func rewriteValuePPC64_OpLsh32x64(v *Value, config *Config) bool { } // match: (Lsh32x64 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 v2.AddArg(y) @@ -3112,23 +3160,27 @@ func rewriteValuePPC64_OpLsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh32x8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x8 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3137,23 +3189,27 @@ func rewriteValuePPC64_OpLsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh64x16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x16 x y) // cond: - // result: (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) + // result: (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3162,9 +3218,13 @@ func rewriteValuePPC64_OpLsh64x16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh64x32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh64x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x32 x (Const64 [c])) // cond: uint32(c) < 64 // result: (SLDconst x [c]) @@ -3203,18 +3263,18 @@ func rewriteValuePPC64_OpLsh64x32(v *Value, config *Config) bool { } // match: (Lsh64x32 x y) // cond: - // result: (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) + // result: (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3223,9 +3283,13 @@ func rewriteValuePPC64_OpLsh64x32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh64x64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh64x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x64 x (Const64 [c])) // cond: uint64(c) < 64 // result: (SLDconst x [c]) @@ -3280,15 +3344,15 @@ func rewriteValuePPC64_OpLsh64x64(v *Value, config *Config) bool { } // match: (Lsh64x64 x y) // cond: - // result: (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) + // result: (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 v2.AddArg(y) @@ -3298,23 +3362,27 @@ func rewriteValuePPC64_OpLsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh64x8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x8 x y) // cond: - // result: (SLD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) + // result: (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3323,23 +3391,27 @@ func rewriteValuePPC64_OpLsh64x8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh8x16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x16 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -8 - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3348,9 +3420,13 @@ func rewriteValuePPC64_OpLsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh8x32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x32 x (Const64 [c])) // cond: uint32(c) < 8 // result: (SLWconst x [c]) @@ -3389,18 +3465,18 @@ func rewriteValuePPC64_OpLsh8x32(v *Value, config *Config) bool { } // match: (Lsh8x32 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -8 - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3409,9 +3485,13 @@ func rewriteValuePPC64_OpLsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh8x64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SLWconst x [c]) @@ -3466,15 +3546,15 @@ func rewriteValuePPC64_OpLsh8x64(v *Value, config *Config) bool { } // match: (Lsh8x64 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -8 v2.AddArg(y) @@ -3484,23 +3564,27 @@ func rewriteValuePPC64_OpLsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpLsh8x8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpLsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x8 x y) // cond: - // result: (SLW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) + // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SLW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -8 - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3509,9 +3593,13 @@ func rewriteValuePPC64_OpLsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMod16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpMod16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16 x y) // cond: // result: (Mod32 (SignExt16to32 x) (SignExt16to32 y)) @@ -3519,18 +3607,22 @@ func rewriteValuePPC64_OpMod16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMod32) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuePPC64_OpMod16u(v *Value, config *Config) bool { +func rewriteValuePPC64_OpMod16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16u x y) // cond: // result: (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y)) @@ -3538,18 +3630,22 @@ func rewriteValuePPC64_OpMod16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMod32u) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuePPC64_OpMod32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpMod32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32 x y) // cond: // result: (SUB x (MULLW y (DIVW x y))) @@ -3558,9 +3654,9 @@ func rewriteValuePPC64_OpMod32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64SUB) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64MULLW, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpPPC64MULLW, fe.TypeInt32()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64DIVW, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpPPC64DIVW, fe.TypeInt32()) v1.AddArg(x) v1.AddArg(y) v0.AddArg(v1) @@ -3568,9 +3664,13 @@ func rewriteValuePPC64_OpMod32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMod32u(v *Value, config *Config) bool { +func rewriteValuePPC64_OpMod32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32u x y) // cond: // result: (SUB x (MULLW y (DIVWU x y))) @@ -3579,9 +3679,9 @@ func rewriteValuePPC64_OpMod32u(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64SUB) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64MULLW, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpPPC64MULLW, fe.TypeInt32()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64DIVWU, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpPPC64DIVWU, fe.TypeInt32()) v1.AddArg(x) v1.AddArg(y) v0.AddArg(v1) @@ -3589,9 +3689,13 @@ func rewriteValuePPC64_OpMod32u(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMod64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpMod64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod64 x y) // cond: // result: (SUB x (MULLD y (DIVD x y))) @@ -3600,9 +3704,9 @@ func rewriteValuePPC64_OpMod64(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64SUB) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64MULLD, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64MULLD, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64DIVD, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64DIVD, fe.TypeInt64()) v1.AddArg(x) v1.AddArg(y) v0.AddArg(v1) @@ -3610,9 +3714,13 @@ func rewriteValuePPC64_OpMod64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMod64u(v *Value, config *Config) bool { +func rewriteValuePPC64_OpMod64u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod64u x y) // cond: // result: (SUB x (MULLD y (DIVDU x y))) @@ -3621,9 +3729,9 @@ func rewriteValuePPC64_OpMod64u(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64SUB) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64MULLD, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64MULLD, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64DIVDU, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64DIVDU, fe.TypeInt64()) v1.AddArg(x) v1.AddArg(y) v0.AddArg(v1) @@ -3631,9 +3739,13 @@ func rewriteValuePPC64_OpMod64u(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMod8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpMod8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8 x y) // cond: // result: (Mod32 (SignExt8to32 x) (SignExt8to32 y)) @@ -3641,18 +3753,22 @@ func rewriteValuePPC64_OpMod8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMod32) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuePPC64_OpMod8u(v *Value, config *Config) bool { +func rewriteValuePPC64_OpMod8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8u x y) // cond: // result: (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y)) @@ -3660,18 +3776,22 @@ func rewriteValuePPC64_OpMod8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpMod32u) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { +func rewriteValuePPC64_OpMove(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Move [0] _ _ mem) // cond: // result: mem @@ -3697,7 +3817,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpPPC64MOVBstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -3720,7 +3840,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { } v.reset(OpPPC64MOVHstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -3740,14 +3860,14 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v.reset(OpPPC64MOVBstore) v.AuxInt = 1 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v0.AuxInt = 1 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -3771,7 +3891,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { } v.reset(OpPPC64MOVWstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVWload, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVWload, fe.TypeInt32()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -3795,14 +3915,14 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v.reset(OpPPC64MOVHstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -3823,7 +3943,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v.reset(OpPPC64MOVBstore) v.AuxInt = 3 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v0.AuxInt = 3 v0.AddArg(src) v0.AddArg(mem) @@ -3831,7 +3951,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem) v1.AuxInt = 2 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v2.AuxInt = 2 v2.AddArg(src) v2.AddArg(mem) @@ -3839,14 +3959,14 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem) v3.AuxInt = 1 v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v4.AuxInt = 1 v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem) v5.AddArg(dst) - v6 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v6 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v6.AddArg(src) v6.AddArg(mem) v5.AddArg(v6) @@ -3872,7 +3992,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { } v.reset(OpPPC64MOVDstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVDload, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVDload, fe.TypeInt64()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -3896,14 +4016,14 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v.reset(OpPPC64MOVWstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVWZload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVWZload, fe.TypeUInt32()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpPPC64MOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpPPC64MOVWZload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpPPC64MOVWZload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -3928,7 +4048,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v.reset(OpPPC64MOVHstore) v.AuxInt = 6 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16()) v0.AuxInt = 6 v0.AddArg(src) v0.AddArg(mem) @@ -3936,7 +4056,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem) v1.AuxInt = 4 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16()) v2.AuxInt = 4 v2.AddArg(src) v2.AddArg(mem) @@ -3944,14 +4064,14 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem) v3.AuxInt = 2 v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16()) + v4 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16()) v4.AuxInt = 2 v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) v5 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem) v5.AddArg(dst) - v6 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16()) + v6 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16()) v6.AddArg(src) v6.AddArg(mem) v5.AddArg(v6) @@ -3974,7 +4094,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v.reset(OpPPC64MOVBstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) @@ -3982,14 +4102,14 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem) v1.AuxInt = 1 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v2.AuxInt = 1 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8()) + v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -4023,9 +4143,7 @@ func rewriteValuePPC64_OpMove(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpMul16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpMul16(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULLW x y) @@ -4038,9 +4156,7 @@ func rewriteValuePPC64_OpMul16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpMul32(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULLW x y) @@ -4053,9 +4169,7 @@ func rewriteValuePPC64_OpMul32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMul32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpMul32F(v *Value) bool { // match: (Mul32F x y) // cond: // result: (FMULS x y) @@ -4068,9 +4182,7 @@ func rewriteValuePPC64_OpMul32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMul64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpMul64(v *Value) bool { // match: (Mul64 x y) // cond: // result: (MULLD x y) @@ -4083,9 +4195,7 @@ func rewriteValuePPC64_OpMul64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMul64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpMul64F(v *Value) bool { // match: (Mul64F x y) // cond: // result: (FMUL x y) @@ -4098,9 +4208,7 @@ func rewriteValuePPC64_OpMul64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpMul8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpMul8(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULLW x y) @@ -4113,9 +4221,7 @@ func rewriteValuePPC64_OpMul8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeg16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpNeg16(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEG x) @@ -4126,9 +4232,7 @@ func rewriteValuePPC64_OpNeg16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeg32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpNeg32(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEG x) @@ -4139,9 +4243,7 @@ func rewriteValuePPC64_OpNeg32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeg32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpNeg32F(v *Value) bool { // match: (Neg32F x) // cond: // result: (FNEG x) @@ -4152,9 +4254,7 @@ func rewriteValuePPC64_OpNeg32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeg64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpNeg64(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEG x) @@ -4165,9 +4265,7 @@ func rewriteValuePPC64_OpNeg64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeg64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpNeg64F(v *Value) bool { // match: (Neg64F x) // cond: // result: (FNEG x) @@ -4178,9 +4276,7 @@ func rewriteValuePPC64_OpNeg64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeg8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpNeg8(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEG x) @@ -4191,9 +4287,13 @@ func rewriteValuePPC64_OpNeg8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeq16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpNeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq16 x y) // cond: isSigned(x.Type) && isSigned(y.Type) // result: (NotEqual (CMPW (SignExt16to32 x) (SignExt16to32 y))) @@ -4205,10 +4305,10 @@ func rewriteValuePPC64_OpNeq16(v *Value, config *Config) bool { } v.reset(OpPPC64NotEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -4222,17 +4322,17 @@ func rewriteValuePPC64_OpNeq16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64NotEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpNeq32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpNeq32(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -4249,7 +4349,7 @@ func rewriteValuePPC64_OpNeq32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeq32F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpNeq32F(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -4266,7 +4366,7 @@ func rewriteValuePPC64_OpNeq32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeq64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpNeq64(v *Value) bool { b := v.Block _ = b // match: (Neq64 x y) @@ -4283,7 +4383,7 @@ func rewriteValuePPC64_OpNeq64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeq64F(v *Value, config *Config) bool { +func rewriteValuePPC64_OpNeq64F(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -4300,9 +4400,13 @@ func rewriteValuePPC64_OpNeq64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeq8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpNeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq8 x y) // cond: isSigned(x.Type) && isSigned(y.Type) // result: (NotEqual (CMPW (SignExt8to32 x) (SignExt8to32 y))) @@ -4314,10 +4418,10 @@ func rewriteValuePPC64_OpNeq8(v *Value, config *Config) bool { } v.reset(OpPPC64NotEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) @@ -4331,19 +4435,17 @@ func rewriteValuePPC64_OpNeq8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpPPC64NotEqual) v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags) - v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValuePPC64_OpNeqB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpNeqB(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -4356,7 +4458,7 @@ func rewriteValuePPC64_OpNeqB(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNeqPtr(v *Value, config *Config) bool { +func rewriteValuePPC64_OpNeqPtr(v *Value) bool { b := v.Block _ = b // match: (NeqPtr x y) @@ -4373,9 +4475,7 @@ func rewriteValuePPC64_OpNeqPtr(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNilCheck(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpNilCheck(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -4388,9 +4488,7 @@ func rewriteValuePPC64_OpNilCheck(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpNot(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpNot(v *Value) bool { // match: (Not x) // cond: // result: (XORconst [1] x) @@ -4402,26 +4500,28 @@ func rewriteValuePPC64_OpNot(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpOffPtr(v *Value, config *Config) bool { +func rewriteValuePPC64_OpOffPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (OffPtr [off] ptr) // cond: - // result: (ADD (MOVDconst <config.Frontend().TypeInt64()> [off]) ptr) + // result: (ADD (MOVDconst <fe.TypeInt64()> [off]) ptr) for { off := v.AuxInt ptr := v.Args[0] v.reset(OpPPC64ADD) - v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, config.Frontend().TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, fe.TypeInt64()) v0.AuxInt = off v.AddArg(v0) v.AddArg(ptr) return true } } -func rewriteValuePPC64_OpOr16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpOr16(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -4434,9 +4534,7 @@ func rewriteValuePPC64_OpOr16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpOr32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpOr32(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -4449,9 +4547,7 @@ func rewriteValuePPC64_OpOr32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpOr64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpOr64(v *Value) bool { // match: (Or64 x y) // cond: // result: (OR x y) @@ -4464,9 +4560,7 @@ func rewriteValuePPC64_OpOr64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpOr8(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -4479,9 +4573,7 @@ func rewriteValuePPC64_OpOr8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpOrB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpOrB(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -4494,9 +4586,7 @@ func rewriteValuePPC64_OpOrB(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpPPC64ADD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64ADD(v *Value) bool { // match: (ADD (MOVDconst [c]) x) // cond: is32Bit(c) // result: (ADDconst [c] x) @@ -4535,9 +4625,7 @@ func rewriteValuePPC64_OpPPC64ADD(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64ADDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64ADDconst(v *Value) bool { // match: (ADDconst [c] (ADDconst [d] x)) // cond: is32Bit(c+d) // result: (ADDconst [c+d] x) @@ -4590,9 +4678,7 @@ func rewriteValuePPC64_OpPPC64ADDconst(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64AND(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64AND(v *Value) bool { // match: (AND x (NOR y y)) // cond: // result: (ANDN x y) @@ -4703,9 +4789,7 @@ func rewriteValuePPC64_OpPPC64AND(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64ANDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64ANDconst(v *Value) bool { // match: (ANDconst [c] (ANDconst [d] x)) // cond: // result: (ANDconst [c&d] x) @@ -4844,7 +4928,7 @@ func rewriteValuePPC64_OpPPC64ANDconst(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64CMP(v *Value, config *Config) bool { +func rewriteValuePPC64_OpPPC64CMP(v *Value) bool { b := v.Block _ = b // match: (CMP x (MOVDconst [c])) @@ -4887,7 +4971,7 @@ func rewriteValuePPC64_OpPPC64CMP(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPU(v *Value, config *Config) bool { +func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool { b := v.Block _ = b // match: (CMPU x (MOVDconst [c])) @@ -4930,9 +5014,7 @@ func rewriteValuePPC64_OpPPC64CMPU(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPUconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64CMPUconst(v *Value) bool { // match: (CMPUconst (MOVDconst [x]) [y]) // cond: int64(x)==int64(y) // result: (FlagEQ) @@ -4983,7 +5065,7 @@ func rewriteValuePPC64_OpPPC64CMPUconst(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPW(v *Value, config *Config) bool { +func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool { b := v.Block _ = b // match: (CMPW x (MOVWreg y)) @@ -5056,7 +5138,7 @@ func rewriteValuePPC64_OpPPC64CMPW(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPWU(v *Value, config *Config) bool { +func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool { b := v.Block _ = b // match: (CMPWU x (MOVWZreg y)) @@ -5129,9 +5211,7 @@ func rewriteValuePPC64_OpPPC64CMPWU(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value) bool { // match: (CMPWUconst (MOVDconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -5182,9 +5262,7 @@ func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64CMPWconst(v *Value) bool { // match: (CMPWconst (MOVDconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -5235,9 +5313,7 @@ func rewriteValuePPC64_OpPPC64CMPWconst(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64CMPconst(v *Value) bool { // match: (CMPconst (MOVDconst [x]) [y]) // cond: int64(x)==int64(y) // result: (FlagEQ) @@ -5288,9 +5364,7 @@ func rewriteValuePPC64_OpPPC64CMPconst(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64Equal(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64Equal(v *Value) bool { // match: (Equal (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -5342,9 +5416,7 @@ func rewriteValuePPC64_OpPPC64Equal(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64FMOVDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64FMOVDload(v *Value) bool { // match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -5394,9 +5466,7 @@ func rewriteValuePPC64_OpPPC64FMOVDload(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value) bool { // match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is16Bit(off1+off2) // result: (FMOVDstore [off1+off2] {sym} ptr val mem) @@ -5450,9 +5520,7 @@ func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64FMOVSload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64FMOVSload(v *Value) bool { // match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -5502,9 +5570,7 @@ func rewriteValuePPC64_OpPPC64FMOVSload(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value) bool { // match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is16Bit(off1+off2) // result: (FMOVSstore [off1+off2] {sym} ptr val mem) @@ -5558,9 +5624,7 @@ func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value) bool { // match: (GreaterEqual (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -5612,9 +5676,7 @@ func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64GreaterThan(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64GreaterThan(v *Value) bool { // match: (GreaterThan (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -5666,9 +5728,7 @@ func rewriteValuePPC64_OpPPC64GreaterThan(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64LessEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64LessEqual(v *Value) bool { // match: (LessEqual (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -5720,9 +5780,7 @@ func rewriteValuePPC64_OpPPC64LessEqual(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64LessThan(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64LessThan(v *Value) bool { // match: (LessThan (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -5774,9 +5832,7 @@ func rewriteValuePPC64_OpPPC64LessThan(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBZload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVBZload(v *Value) bool { // match: (MOVBZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVBZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -5826,9 +5882,7 @@ func rewriteValuePPC64_OpPPC64MOVBZload(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value) bool { // match: (MOVBZreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0xFF // result: y @@ -5900,9 +5954,7 @@ func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVBreg(v *Value) bool { // match: (MOVBreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0x7F // result: y @@ -5961,9 +6013,7 @@ func rewriteValuePPC64_OpPPC64MOVBreg(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool { // match: (MOVBstore [off1] {sym} (ADDconst [off2] x) val mem) // cond: is16Bit(off1+off2) // result: (MOVBstore [off1+off2] {sym} x val mem) @@ -6082,9 +6132,7 @@ func rewriteValuePPC64_OpPPC64MOVBstore(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value) bool { // match: (MOVBstorezero [off1] {sym} (ADDconst [off2] x) mem) // cond: is16Bit(off1+off2) // result: (MOVBstorezero [off1+off2] {sym} x mem) @@ -6134,9 +6182,7 @@ func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool { // match: (MOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -6186,9 +6232,7 @@ func rewriteValuePPC64_OpPPC64MOVDload(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDconst [off2] x) val mem) // cond: is16Bit(off1+off2) // result: (MOVDstore [off1+off2] {sym} x val mem) @@ -6265,9 +6309,7 @@ func rewriteValuePPC64_OpPPC64MOVDstore(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool { // match: (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem) // cond: is16Bit(off1+off2) // result: (MOVDstorezero [off1+off2] {sym} x mem) @@ -6317,9 +6359,7 @@ func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHZload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVHZload(v *Value) bool { // match: (MOVHZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVHZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -6369,9 +6409,7 @@ func rewriteValuePPC64_OpPPC64MOVHZload(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value) bool { // match: (MOVHZreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0xFFFF // result: y @@ -6456,9 +6494,7 @@ func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVHload(v *Value) bool { // match: (MOVHload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -6508,9 +6544,7 @@ func rewriteValuePPC64_OpPPC64MOVHload(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVHreg(v *Value) bool { // match: (MOVHreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0x7FFF // result: y @@ -6595,9 +6629,7 @@ func rewriteValuePPC64_OpPPC64MOVHreg(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVHstore(v *Value) bool { // match: (MOVHstore [off1] {sym} (ADDconst [off2] x) val mem) // cond: is16Bit(off1+off2) // result: (MOVHstore [off1+off2] {sym} x val mem) @@ -6716,9 +6748,7 @@ func rewriteValuePPC64_OpPPC64MOVHstore(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value) bool { // match: (MOVHstorezero [off1] {sym} (ADDconst [off2] x) mem) // cond: is16Bit(off1+off2) // result: (MOVHstorezero [off1+off2] {sym} x mem) @@ -6768,9 +6798,7 @@ func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWZload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVWZload(v *Value) bool { // match: (MOVWZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVWZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -6820,9 +6848,7 @@ func rewriteValuePPC64_OpPPC64MOVWZload(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value) bool { // match: (MOVWZreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0xFFFFFFFF // result: y @@ -6915,9 +6941,7 @@ func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool { // match: (MOVWload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -6967,9 +6991,7 @@ func rewriteValuePPC64_OpPPC64MOVWload(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWreg(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVWreg(v *Value) bool { // match: (MOVWreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0xFFFF // result: y @@ -7062,9 +7084,7 @@ func rewriteValuePPC64_OpPPC64MOVWreg(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVWstore(v *Value) bool { // match: (MOVWstore [off1] {sym} (ADDconst [off2] x) val mem) // cond: is16Bit(off1+off2) // result: (MOVWstore [off1+off2] {sym} x val mem) @@ -7183,9 +7203,7 @@ func rewriteValuePPC64_OpPPC64MOVWstore(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value) bool { // match: (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem) // cond: is16Bit(off1+off2) // result: (MOVWstorezero [off1+off2] {sym} x mem) @@ -7235,9 +7253,7 @@ func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value) bool { // match: (MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _))) // cond: c < 0 && d > 0 && c + d < 0 // result: (MOVDconst [-1]) @@ -7261,9 +7277,7 @@ func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64NotEqual(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64NotEqual(v *Value) bool { // match: (NotEqual (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -7315,9 +7329,7 @@ func rewriteValuePPC64_OpPPC64NotEqual(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64OR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64OR(v *Value) bool { // match: (OR (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [c|d]) @@ -7374,9 +7386,7 @@ func rewriteValuePPC64_OpPPC64OR(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64ORN(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64ORN(v *Value) bool { // match: (ORN x (MOVDconst [-1])) // cond: // result: x @@ -7396,9 +7406,7 @@ func rewriteValuePPC64_OpPPC64ORN(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64ORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64ORconst(v *Value) bool { // match: (ORconst [c] (ORconst [d] x)) // cond: // result: (ORconst [c|d] x) @@ -7441,9 +7449,7 @@ func rewriteValuePPC64_OpPPC64ORconst(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64SUB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64SUB(v *Value) bool { // match: (SUB x (MOVDconst [c])) // cond: is32Bit(-c) // result: (ADDconst [-c] x) @@ -7464,9 +7470,7 @@ func rewriteValuePPC64_OpPPC64SUB(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64XOR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64XOR(v *Value) bool { // match: (XOR (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [c^d]) @@ -7523,9 +7527,7 @@ func rewriteValuePPC64_OpPPC64XOR(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpPPC64XORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpPPC64XORconst(v *Value) bool { // match: (XORconst [c] (XORconst [d] x)) // cond: // result: (XORconst [c^d] x) @@ -7557,9 +7559,7 @@ func rewriteValuePPC64_OpPPC64XORconst(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpRound32F(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -7571,9 +7571,7 @@ func rewriteValuePPC64_OpRound32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpRound64F(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -7585,25 +7583,29 @@ func rewriteValuePPC64_OpRound64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh16Ux16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh16Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux16 x y) // cond: - // result: (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) + // result: (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -16 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -7612,9 +7614,13 @@ func rewriteValuePPC64_OpRsh16Ux16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh16Ux32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh16Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux32 x (Const64 [c])) // cond: uint32(c) < 16 // result: (SRWconst (ZeroExt16to32 x) [c]) @@ -7630,7 +7636,7 @@ func rewriteValuePPC64_OpRsh16Ux32(v *Value, config *Config) bool { } v.reset(OpPPC64SRWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -7650,27 +7656,27 @@ func rewriteValuePPC64_OpRsh16Ux32(v *Value, config *Config) bool { } v.reset(OpPPC64SRWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh16Ux32 x y) // cond: - // result: (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) + // result: (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -16 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -7679,9 +7685,13 @@ func rewriteValuePPC64_OpRsh16Ux32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh16Ux64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh16Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SRWconst (ZeroExt16to32 x) [c]) @@ -7697,7 +7707,7 @@ func rewriteValuePPC64_OpRsh16Ux64(v *Value, config *Config) bool { } v.reset(OpPPC64SRWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -7733,24 +7743,24 @@ func rewriteValuePPC64_OpRsh16Ux64(v *Value, config *Config) bool { } v.reset(OpPPC64SRWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh16Ux64 x y) // cond: - // result: (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) + // result: (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -16 v3.AddArg(y) @@ -7760,25 +7770,29 @@ func rewriteValuePPC64_OpRsh16Ux64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh16Ux8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh16Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux8 x y) // cond: - // result: (SRW (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) + // result: (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -16 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -7787,25 +7801,29 @@ func rewriteValuePPC64_OpRsh16Ux8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh16x16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x16 x y) // cond: - // result: (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) + // result: (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -16 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -7814,9 +7832,13 @@ func rewriteValuePPC64_OpRsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh16x32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x32 x (Const64 [c])) // cond: uint32(c) < 16 // result: (SRAWconst (SignExt16to32 x) [c]) @@ -7832,7 +7854,7 @@ func rewriteValuePPC64_OpRsh16x32(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -7852,27 +7874,27 @@ func rewriteValuePPC64_OpRsh16x32(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh16x32 x y) // cond: - // result: (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) + // result: (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -16 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -7881,9 +7903,13 @@ func rewriteValuePPC64_OpRsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh16x64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SRAWconst (SignExt16to32 x) [c]) @@ -7899,7 +7925,7 @@ func rewriteValuePPC64_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -7919,7 +7945,7 @@ func rewriteValuePPC64_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = 63 - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -7939,24 +7965,24 @@ func rewriteValuePPC64_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh16x64 x y) // cond: - // result: (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) + // result: (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -16 v3.AddArg(y) @@ -7966,25 +7992,29 @@ func rewriteValuePPC64_OpRsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh16x8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x8 x y) // cond: - // result: (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) + // result: (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -16 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -7993,23 +8023,27 @@ func rewriteValuePPC64_OpRsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh32Ux16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh32Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux16 x y) // cond: - // result: (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) + // result: (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8018,9 +8052,13 @@ func rewriteValuePPC64_OpRsh32Ux16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh32Ux32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh32Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux32 x (Const64 [c])) // cond: uint32(c) < 32 // result: (SRWconst x [c]) @@ -8059,18 +8097,18 @@ func rewriteValuePPC64_OpRsh32Ux32(v *Value, config *Config) bool { } // match: (Rsh32Ux32 x y) // cond: - // result: (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) + // result: (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8079,9 +8117,13 @@ func rewriteValuePPC64_OpRsh32Ux32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh32Ux64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh32Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SRWconst x [c]) @@ -8136,15 +8178,15 @@ func rewriteValuePPC64_OpRsh32Ux64(v *Value, config *Config) bool { } // match: (Rsh32Ux64 x y) // cond: - // result: (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) + // result: (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 v2.AddArg(y) @@ -8154,23 +8196,27 @@ func rewriteValuePPC64_OpRsh32Ux64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh32Ux8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh32Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux8 x y) // cond: - // result: (SRW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) + // result: (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8179,23 +8225,27 @@ func rewriteValuePPC64_OpRsh32Ux8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh32x16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x16 x y) // cond: - // result: (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) + // result: (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8204,9 +8254,13 @@ func rewriteValuePPC64_OpRsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh32x32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh32x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x32 x (Const64 [c])) // cond: uint32(c) < 32 // result: (SRAWconst x [c]) @@ -8245,18 +8299,18 @@ func rewriteValuePPC64_OpRsh32x32(v *Value, config *Config) bool { } // match: (Rsh32x32 x y) // cond: - // result: (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) + // result: (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8265,9 +8319,13 @@ func rewriteValuePPC64_OpRsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh32x64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh32x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SRAWconst x [c]) @@ -8324,15 +8382,15 @@ func rewriteValuePPC64_OpRsh32x64(v *Value, config *Config) bool { } // match: (Rsh32x64 x y) // cond: - // result: (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) + // result: (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 v2.AddArg(y) @@ -8342,23 +8400,27 @@ func rewriteValuePPC64_OpRsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh32x8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x8 x y) // cond: - // result: (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) + // result: (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -32 - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8367,23 +8429,27 @@ func rewriteValuePPC64_OpRsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh64Ux16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh64Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux16 x y) // cond: - // result: (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) + // result: (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8392,9 +8458,13 @@ func rewriteValuePPC64_OpRsh64Ux16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh64Ux32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh64Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux32 x (Const64 [c])) // cond: uint32(c) < 64 // result: (SRDconst x [c]) @@ -8433,18 +8503,18 @@ func rewriteValuePPC64_OpRsh64Ux32(v *Value, config *Config) bool { } // match: (Rsh64Ux32 x y) // cond: - // result: (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) + // result: (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8453,9 +8523,13 @@ func rewriteValuePPC64_OpRsh64Ux32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh64Ux64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh64Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux64 x (Const64 [c])) // cond: uint64(c) < 64 // result: (SRDconst x [c]) @@ -8510,15 +8584,15 @@ func rewriteValuePPC64_OpRsh64Ux64(v *Value, config *Config) bool { } // match: (Rsh64Ux64 x y) // cond: - // result: (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) + // result: (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 v2.AddArg(y) @@ -8528,23 +8602,27 @@ func rewriteValuePPC64_OpRsh64Ux64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh64Ux8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh64Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux8 x y) // cond: - // result: (SRD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) + // result: (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8553,23 +8631,27 @@ func rewriteValuePPC64_OpRsh64Ux8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh64x16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x16 x y) // cond: - // result: (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) + // result: (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8578,9 +8660,13 @@ func rewriteValuePPC64_OpRsh64x16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh64x32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh64x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x32 x (Const64 [c])) // cond: uint32(c) < 64 // result: (SRADconst x [c]) @@ -8619,18 +8705,18 @@ func rewriteValuePPC64_OpRsh64x32(v *Value, config *Config) bool { } // match: (Rsh64x32 x y) // cond: - // result: (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) + // result: (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8639,9 +8725,13 @@ func rewriteValuePPC64_OpRsh64x32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh64x64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh64x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x64 x (Const64 [c])) // cond: uint64(c) < 64 // result: (SRADconst x [c]) @@ -8698,15 +8788,15 @@ func rewriteValuePPC64_OpRsh64x64(v *Value, config *Config) bool { } // match: (Rsh64x64 x y) // cond: - // result: (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) + // result: (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 v2.AddArg(y) @@ -8716,23 +8806,27 @@ func rewriteValuePPC64_OpRsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh64x8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x8 x y) // cond: - // result: (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) + // result: (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAD) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v0.AddArg(y) - v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v2.AuxInt = -64 - v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -8741,25 +8835,29 @@ func rewriteValuePPC64_OpRsh64x8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh8Ux16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh8Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux16 x y) // cond: - // result: (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) + // result: (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -8 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -8768,9 +8866,13 @@ func rewriteValuePPC64_OpRsh8Ux16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh8Ux32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh8Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux32 x (Const64 [c])) // cond: uint32(c) < 8 // result: (SRWconst (ZeroExt8to32 x) [c]) @@ -8786,7 +8888,7 @@ func rewriteValuePPC64_OpRsh8Ux32(v *Value, config *Config) bool { } v.reset(OpPPC64SRWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -8806,27 +8908,27 @@ func rewriteValuePPC64_OpRsh8Ux32(v *Value, config *Config) bool { } v.reset(OpPPC64SRWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh8Ux32 x y) // cond: - // result: (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) + // result: (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -8 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -8835,9 +8937,13 @@ func rewriteValuePPC64_OpRsh8Ux32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh8Ux64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh8Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SRWconst (ZeroExt8to32 x) [c]) @@ -8853,7 +8959,7 @@ func rewriteValuePPC64_OpRsh8Ux64(v *Value, config *Config) bool { } v.reset(OpPPC64SRWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -8889,24 +8995,24 @@ func rewriteValuePPC64_OpRsh8Ux64(v *Value, config *Config) bool { } v.reset(OpPPC64SRWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh8Ux64 x y) // cond: - // result: (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) + // result: (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -8 v3.AddArg(y) @@ -8916,25 +9022,29 @@ func rewriteValuePPC64_OpRsh8Ux64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh8Ux8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh8Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux8 x y) // cond: - // result: (SRW (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) + // result: (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRW) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -8 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -8943,25 +9053,29 @@ func rewriteValuePPC64_OpRsh8Ux8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh8x16(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x16 x y) // cond: - // result: (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) + // result: (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -8 - v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -8970,9 +9084,13 @@ func rewriteValuePPC64_OpRsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh8x32(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x32 x (Const64 [c])) // cond: uint32(c) < 8 // result: (SRAWconst (SignExt8to32 x) [c]) @@ -8988,7 +9106,7 @@ func rewriteValuePPC64_OpRsh8x32(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -9008,27 +9126,27 @@ func rewriteValuePPC64_OpRsh8x32(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh8x32 x y) // cond: - // result: (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) + // result: (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -8 - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -9037,9 +9155,13 @@ func rewriteValuePPC64_OpRsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh8x64(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SRAWconst (SignExt8to32 x) [c]) @@ -9055,7 +9177,7 @@ func rewriteValuePPC64_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -9075,7 +9197,7 @@ func rewriteValuePPC64_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = 63 - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -9095,24 +9217,24 @@ func rewriteValuePPC64_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpPPC64SRAWconst) v.AuxInt = c - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh8x64 x y) // cond: - // result: (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) + // result: (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -8 v3.AddArg(y) @@ -9122,25 +9244,29 @@ func rewriteValuePPC64_OpRsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpRsh8x8(v *Value, config *Config) bool { +func rewriteValuePPC64_OpRsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x8 x y) // cond: - // result: (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) + // result: (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) for { x := v.Args[0] y := v.Args[1] v.reset(OpPPC64SRAW) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64()) v1.AddArg(y) - v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64()) v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags) v3.AuxInt = -8 - v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -9149,9 +9275,7 @@ func rewriteValuePPC64_OpRsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSignExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSignExt16to32(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -9162,9 +9286,7 @@ func rewriteValuePPC64_OpSignExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSignExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSignExt16to64(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVHreg x) @@ -9175,9 +9297,7 @@ func rewriteValuePPC64_OpSignExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSignExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSignExt32to64(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVWreg x) @@ -9188,9 +9308,7 @@ func rewriteValuePPC64_OpSignExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSignExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSignExt8to16(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -9201,9 +9319,7 @@ func rewriteValuePPC64_OpSignExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSignExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSignExt8to32(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -9214,9 +9330,7 @@ func rewriteValuePPC64_OpSignExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSignExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSignExt8to64(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBreg x) @@ -9227,7 +9341,7 @@ func rewriteValuePPC64_OpSignExt8to64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSlicemask(v *Value, config *Config) bool { +func rewriteValuePPC64_OpSlicemask(v *Value) bool { b := v.Block _ = b // match: (Slicemask <t> x) @@ -9244,9 +9358,7 @@ func rewriteValuePPC64_OpSlicemask(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSqrt(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSqrt(v *Value) bool { // match: (Sqrt x) // cond: // result: (FSQRT x) @@ -9257,9 +9369,7 @@ func rewriteValuePPC64_OpSqrt(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpStaticCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpStaticCall(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -9274,9 +9384,7 @@ func rewriteValuePPC64_OpStaticCall(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpStore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpStore(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type) // result: (FMOVDstore ptr val mem) @@ -9398,9 +9506,7 @@ func rewriteValuePPC64_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpSub16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSub16(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUB x y) @@ -9413,9 +9519,7 @@ func rewriteValuePPC64_OpSub16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSub32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSub32(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUB x y) @@ -9428,9 +9532,7 @@ func rewriteValuePPC64_OpSub32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSub32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSub32F(v *Value) bool { // match: (Sub32F x y) // cond: // result: (FSUBS x y) @@ -9443,9 +9545,7 @@ func rewriteValuePPC64_OpSub32F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSub64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSub64(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUB x y) @@ -9458,9 +9558,7 @@ func rewriteValuePPC64_OpSub64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSub64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSub64F(v *Value) bool { // match: (Sub64F x y) // cond: // result: (FSUB x y) @@ -9473,9 +9571,7 @@ func rewriteValuePPC64_OpSub64F(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSub8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSub8(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUB x y) @@ -9488,9 +9584,7 @@ func rewriteValuePPC64_OpSub8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpSubPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpSubPtr(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -9503,9 +9597,7 @@ func rewriteValuePPC64_OpSubPtr(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpTrunc16to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpTrunc16to8(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: (MOVBreg x) @@ -9516,9 +9608,7 @@ func rewriteValuePPC64_OpTrunc16to8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpTrunc32to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpTrunc32to16(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: (MOVHreg x) @@ -9529,9 +9619,7 @@ func rewriteValuePPC64_OpTrunc32to16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpTrunc32to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpTrunc32to8(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: (MOVBreg x) @@ -9542,9 +9630,7 @@ func rewriteValuePPC64_OpTrunc32to8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpTrunc64to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpTrunc64to16(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: (MOVHreg x) @@ -9555,9 +9641,7 @@ func rewriteValuePPC64_OpTrunc64to16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpTrunc64to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpTrunc64to32(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: (MOVWreg x) @@ -9568,9 +9652,7 @@ func rewriteValuePPC64_OpTrunc64to32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpTrunc64to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpTrunc64to8(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: (MOVBreg x) @@ -9581,9 +9663,7 @@ func rewriteValuePPC64_OpTrunc64to8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpXor16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpXor16(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -9596,9 +9676,7 @@ func rewriteValuePPC64_OpXor16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpXor32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpXor32(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -9611,9 +9689,7 @@ func rewriteValuePPC64_OpXor32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpXor64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpXor64(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XOR x y) @@ -9626,9 +9702,7 @@ func rewriteValuePPC64_OpXor64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpXor8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpXor8(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -9641,9 +9715,11 @@ func rewriteValuePPC64_OpXor8(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpZero(v *Value, config *Config) bool { +func rewriteValuePPC64_OpZero(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (Zero [0] _ mem) // cond: // result: mem @@ -9976,9 +10052,7 @@ func rewriteValuePPC64_OpZero(v *Value, config *Config) bool { } return false } -func rewriteValuePPC64_OpZeroExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpZeroExt16to32(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHZreg x) @@ -9989,9 +10063,7 @@ func rewriteValuePPC64_OpZeroExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpZeroExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpZeroExt16to64(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVHZreg x) @@ -10002,9 +10074,7 @@ func rewriteValuePPC64_OpZeroExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpZeroExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpZeroExt32to64(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVWZreg x) @@ -10015,9 +10085,7 @@ func rewriteValuePPC64_OpZeroExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpZeroExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpZeroExt8to16(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBZreg x) @@ -10028,9 +10096,7 @@ func rewriteValuePPC64_OpZeroExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpZeroExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpZeroExt8to32(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBZreg x) @@ -10041,9 +10107,7 @@ func rewriteValuePPC64_OpZeroExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValuePPC64_OpZeroExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuePPC64_OpZeroExt8to64(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBZreg x) @@ -10054,7 +10118,11 @@ func rewriteValuePPC64_OpZeroExt8to64(v *Value, config *Config) bool { return true } } -func rewriteBlockPPC64(b *Block, config *Config) bool { +func rewriteBlockPPC64(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { case BlockPPC64EQ: // match: (EQ (CMPconst [0] (ANDconst [c] x)) yes no) diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go index a43b98dc74..3b8ea93f53 100644 --- a/src/cmd/compile/internal/ssa/rewriteS390X.go +++ b/src/cmd/compile/internal/ssa/rewriteS390X.go @@ -6,718 +6,716 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValueS390X(v *Value, config *Config) bool { +func rewriteValueS390X(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValueS390X_OpAdd16(v, config) + return rewriteValueS390X_OpAdd16(v) case OpAdd32: - return rewriteValueS390X_OpAdd32(v, config) + return rewriteValueS390X_OpAdd32(v) case OpAdd32F: - return rewriteValueS390X_OpAdd32F(v, config) + return rewriteValueS390X_OpAdd32F(v) case OpAdd64: - return rewriteValueS390X_OpAdd64(v, config) + return rewriteValueS390X_OpAdd64(v) case OpAdd64F: - return rewriteValueS390X_OpAdd64F(v, config) + return rewriteValueS390X_OpAdd64F(v) case OpAdd8: - return rewriteValueS390X_OpAdd8(v, config) + return rewriteValueS390X_OpAdd8(v) case OpAddPtr: - return rewriteValueS390X_OpAddPtr(v, config) + return rewriteValueS390X_OpAddPtr(v) case OpAddr: - return rewriteValueS390X_OpAddr(v, config) + return rewriteValueS390X_OpAddr(v) case OpAnd16: - return rewriteValueS390X_OpAnd16(v, config) + return rewriteValueS390X_OpAnd16(v) case OpAnd32: - return rewriteValueS390X_OpAnd32(v, config) + return rewriteValueS390X_OpAnd32(v) case OpAnd64: - return rewriteValueS390X_OpAnd64(v, config) + return rewriteValueS390X_OpAnd64(v) case OpAnd8: - return rewriteValueS390X_OpAnd8(v, config) + return rewriteValueS390X_OpAnd8(v) case OpAndB: - return rewriteValueS390X_OpAndB(v, config) + return rewriteValueS390X_OpAndB(v) case OpAtomicAdd32: - return rewriteValueS390X_OpAtomicAdd32(v, config) + return rewriteValueS390X_OpAtomicAdd32(v) case OpAtomicAdd64: - return rewriteValueS390X_OpAtomicAdd64(v, config) + return rewriteValueS390X_OpAtomicAdd64(v) case OpAtomicCompareAndSwap32: - return rewriteValueS390X_OpAtomicCompareAndSwap32(v, config) + return rewriteValueS390X_OpAtomicCompareAndSwap32(v) case OpAtomicCompareAndSwap64: - return rewriteValueS390X_OpAtomicCompareAndSwap64(v, config) + return rewriteValueS390X_OpAtomicCompareAndSwap64(v) case OpAtomicExchange32: - return rewriteValueS390X_OpAtomicExchange32(v, config) + return rewriteValueS390X_OpAtomicExchange32(v) case OpAtomicExchange64: - return rewriteValueS390X_OpAtomicExchange64(v, config) + return rewriteValueS390X_OpAtomicExchange64(v) case OpAtomicLoad32: - return rewriteValueS390X_OpAtomicLoad32(v, config) + return rewriteValueS390X_OpAtomicLoad32(v) case OpAtomicLoad64: - return rewriteValueS390X_OpAtomicLoad64(v, config) + return rewriteValueS390X_OpAtomicLoad64(v) case OpAtomicLoadPtr: - return rewriteValueS390X_OpAtomicLoadPtr(v, config) + return rewriteValueS390X_OpAtomicLoadPtr(v) case OpAtomicStore32: - return rewriteValueS390X_OpAtomicStore32(v, config) + return rewriteValueS390X_OpAtomicStore32(v) case OpAtomicStore64: - return rewriteValueS390X_OpAtomicStore64(v, config) + return rewriteValueS390X_OpAtomicStore64(v) case OpAtomicStorePtrNoWB: - return rewriteValueS390X_OpAtomicStorePtrNoWB(v, config) + return rewriteValueS390X_OpAtomicStorePtrNoWB(v) case OpAvg64u: - return rewriteValueS390X_OpAvg64u(v, config) + return rewriteValueS390X_OpAvg64u(v) case OpBitLen64: - return rewriteValueS390X_OpBitLen64(v, config) + return rewriteValueS390X_OpBitLen64(v) case OpBswap32: - return rewriteValueS390X_OpBswap32(v, config) + return rewriteValueS390X_OpBswap32(v) case OpBswap64: - return rewriteValueS390X_OpBswap64(v, config) + return rewriteValueS390X_OpBswap64(v) case OpClosureCall: - return rewriteValueS390X_OpClosureCall(v, config) + return rewriteValueS390X_OpClosureCall(v) case OpCom16: - return rewriteValueS390X_OpCom16(v, config) + return rewriteValueS390X_OpCom16(v) case OpCom32: - return rewriteValueS390X_OpCom32(v, config) + return rewriteValueS390X_OpCom32(v) case OpCom64: - return rewriteValueS390X_OpCom64(v, config) + return rewriteValueS390X_OpCom64(v) case OpCom8: - return rewriteValueS390X_OpCom8(v, config) + return rewriteValueS390X_OpCom8(v) case OpConst16: - return rewriteValueS390X_OpConst16(v, config) + return rewriteValueS390X_OpConst16(v) case OpConst32: - return rewriteValueS390X_OpConst32(v, config) + return rewriteValueS390X_OpConst32(v) case OpConst32F: - return rewriteValueS390X_OpConst32F(v, config) + return rewriteValueS390X_OpConst32F(v) case OpConst64: - return rewriteValueS390X_OpConst64(v, config) + return rewriteValueS390X_OpConst64(v) case OpConst64F: - return rewriteValueS390X_OpConst64F(v, config) + return rewriteValueS390X_OpConst64F(v) case OpConst8: - return rewriteValueS390X_OpConst8(v, config) + return rewriteValueS390X_OpConst8(v) case OpConstBool: - return rewriteValueS390X_OpConstBool(v, config) + return rewriteValueS390X_OpConstBool(v) case OpConstNil: - return rewriteValueS390X_OpConstNil(v, config) + return rewriteValueS390X_OpConstNil(v) case OpConvert: - return rewriteValueS390X_OpConvert(v, config) + return rewriteValueS390X_OpConvert(v) case OpCtz32: - return rewriteValueS390X_OpCtz32(v, config) + return rewriteValueS390X_OpCtz32(v) case OpCtz64: - return rewriteValueS390X_OpCtz64(v, config) + return rewriteValueS390X_OpCtz64(v) case OpCvt32Fto32: - return rewriteValueS390X_OpCvt32Fto32(v, config) + return rewriteValueS390X_OpCvt32Fto32(v) case OpCvt32Fto64: - return rewriteValueS390X_OpCvt32Fto64(v, config) + return rewriteValueS390X_OpCvt32Fto64(v) case OpCvt32Fto64F: - return rewriteValueS390X_OpCvt32Fto64F(v, config) + return rewriteValueS390X_OpCvt32Fto64F(v) case OpCvt32to32F: - return rewriteValueS390X_OpCvt32to32F(v, config) + return rewriteValueS390X_OpCvt32to32F(v) case OpCvt32to64F: - return rewriteValueS390X_OpCvt32to64F(v, config) + return rewriteValueS390X_OpCvt32to64F(v) case OpCvt64Fto32: - return rewriteValueS390X_OpCvt64Fto32(v, config) + return rewriteValueS390X_OpCvt64Fto32(v) case OpCvt64Fto32F: - return rewriteValueS390X_OpCvt64Fto32F(v, config) + return rewriteValueS390X_OpCvt64Fto32F(v) case OpCvt64Fto64: - return rewriteValueS390X_OpCvt64Fto64(v, config) + return rewriteValueS390X_OpCvt64Fto64(v) case OpCvt64to32F: - return rewriteValueS390X_OpCvt64to32F(v, config) + return rewriteValueS390X_OpCvt64to32F(v) case OpCvt64to64F: - return rewriteValueS390X_OpCvt64to64F(v, config) + return rewriteValueS390X_OpCvt64to64F(v) case OpDiv16: - return rewriteValueS390X_OpDiv16(v, config) + return rewriteValueS390X_OpDiv16(v) case OpDiv16u: - return rewriteValueS390X_OpDiv16u(v, config) + return rewriteValueS390X_OpDiv16u(v) case OpDiv32: - return rewriteValueS390X_OpDiv32(v, config) + return rewriteValueS390X_OpDiv32(v) case OpDiv32F: - return rewriteValueS390X_OpDiv32F(v, config) + return rewriteValueS390X_OpDiv32F(v) case OpDiv32u: - return rewriteValueS390X_OpDiv32u(v, config) + return rewriteValueS390X_OpDiv32u(v) case OpDiv64: - return rewriteValueS390X_OpDiv64(v, config) + return rewriteValueS390X_OpDiv64(v) case OpDiv64F: - return rewriteValueS390X_OpDiv64F(v, config) + return rewriteValueS390X_OpDiv64F(v) case OpDiv64u: - return rewriteValueS390X_OpDiv64u(v, config) + return rewriteValueS390X_OpDiv64u(v) case OpDiv8: - return rewriteValueS390X_OpDiv8(v, config) + return rewriteValueS390X_OpDiv8(v) case OpDiv8u: - return rewriteValueS390X_OpDiv8u(v, config) + return rewriteValueS390X_OpDiv8u(v) case OpEq16: - return rewriteValueS390X_OpEq16(v, config) + return rewriteValueS390X_OpEq16(v) case OpEq32: - return rewriteValueS390X_OpEq32(v, config) + return rewriteValueS390X_OpEq32(v) case OpEq32F: - return rewriteValueS390X_OpEq32F(v, config) + return rewriteValueS390X_OpEq32F(v) case OpEq64: - return rewriteValueS390X_OpEq64(v, config) + return rewriteValueS390X_OpEq64(v) case OpEq64F: - return rewriteValueS390X_OpEq64F(v, config) + return rewriteValueS390X_OpEq64F(v) case OpEq8: - return rewriteValueS390X_OpEq8(v, config) + return rewriteValueS390X_OpEq8(v) case OpEqB: - return rewriteValueS390X_OpEqB(v, config) + return rewriteValueS390X_OpEqB(v) case OpEqPtr: - return rewriteValueS390X_OpEqPtr(v, config) + return rewriteValueS390X_OpEqPtr(v) case OpGeq16: - return rewriteValueS390X_OpGeq16(v, config) + return rewriteValueS390X_OpGeq16(v) case OpGeq16U: - return rewriteValueS390X_OpGeq16U(v, config) + return rewriteValueS390X_OpGeq16U(v) case OpGeq32: - return rewriteValueS390X_OpGeq32(v, config) + return rewriteValueS390X_OpGeq32(v) case OpGeq32F: - return rewriteValueS390X_OpGeq32F(v, config) + return rewriteValueS390X_OpGeq32F(v) case OpGeq32U: - return rewriteValueS390X_OpGeq32U(v, config) + return rewriteValueS390X_OpGeq32U(v) case OpGeq64: - return rewriteValueS390X_OpGeq64(v, config) + return rewriteValueS390X_OpGeq64(v) case OpGeq64F: - return rewriteValueS390X_OpGeq64F(v, config) + return rewriteValueS390X_OpGeq64F(v) case OpGeq64U: - return rewriteValueS390X_OpGeq64U(v, config) + return rewriteValueS390X_OpGeq64U(v) case OpGeq8: - return rewriteValueS390X_OpGeq8(v, config) + return rewriteValueS390X_OpGeq8(v) case OpGeq8U: - return rewriteValueS390X_OpGeq8U(v, config) + return rewriteValueS390X_OpGeq8U(v) case OpGetClosurePtr: - return rewriteValueS390X_OpGetClosurePtr(v, config) + return rewriteValueS390X_OpGetClosurePtr(v) case OpGetG: - return rewriteValueS390X_OpGetG(v, config) + return rewriteValueS390X_OpGetG(v) case OpGreater16: - return rewriteValueS390X_OpGreater16(v, config) + return rewriteValueS390X_OpGreater16(v) case OpGreater16U: - return rewriteValueS390X_OpGreater16U(v, config) + return rewriteValueS390X_OpGreater16U(v) case OpGreater32: - return rewriteValueS390X_OpGreater32(v, config) + return rewriteValueS390X_OpGreater32(v) case OpGreater32F: - return rewriteValueS390X_OpGreater32F(v, config) + return rewriteValueS390X_OpGreater32F(v) case OpGreater32U: - return rewriteValueS390X_OpGreater32U(v, config) + return rewriteValueS390X_OpGreater32U(v) case OpGreater64: - return rewriteValueS390X_OpGreater64(v, config) + return rewriteValueS390X_OpGreater64(v) case OpGreater64F: - return rewriteValueS390X_OpGreater64F(v, config) + return rewriteValueS390X_OpGreater64F(v) case OpGreater64U: - return rewriteValueS390X_OpGreater64U(v, config) + return rewriteValueS390X_OpGreater64U(v) case OpGreater8: - return rewriteValueS390X_OpGreater8(v, config) + return rewriteValueS390X_OpGreater8(v) case OpGreater8U: - return rewriteValueS390X_OpGreater8U(v, config) + return rewriteValueS390X_OpGreater8U(v) case OpHmul32: - return rewriteValueS390X_OpHmul32(v, config) + return rewriteValueS390X_OpHmul32(v) case OpHmul32u: - return rewriteValueS390X_OpHmul32u(v, config) + return rewriteValueS390X_OpHmul32u(v) case OpHmul64: - return rewriteValueS390X_OpHmul64(v, config) + return rewriteValueS390X_OpHmul64(v) case OpHmul64u: - return rewriteValueS390X_OpHmul64u(v, config) + return rewriteValueS390X_OpHmul64u(v) case OpITab: - return rewriteValueS390X_OpITab(v, config) + return rewriteValueS390X_OpITab(v) case OpInterCall: - return rewriteValueS390X_OpInterCall(v, config) + return rewriteValueS390X_OpInterCall(v) case OpIsInBounds: - return rewriteValueS390X_OpIsInBounds(v, config) + return rewriteValueS390X_OpIsInBounds(v) case OpIsNonNil: - return rewriteValueS390X_OpIsNonNil(v, config) + return rewriteValueS390X_OpIsNonNil(v) case OpIsSliceInBounds: - return rewriteValueS390X_OpIsSliceInBounds(v, config) + return rewriteValueS390X_OpIsSliceInBounds(v) case OpLeq16: - return rewriteValueS390X_OpLeq16(v, config) + return rewriteValueS390X_OpLeq16(v) case OpLeq16U: - return rewriteValueS390X_OpLeq16U(v, config) + return rewriteValueS390X_OpLeq16U(v) case OpLeq32: - return rewriteValueS390X_OpLeq32(v, config) + return rewriteValueS390X_OpLeq32(v) case OpLeq32F: - return rewriteValueS390X_OpLeq32F(v, config) + return rewriteValueS390X_OpLeq32F(v) case OpLeq32U: - return rewriteValueS390X_OpLeq32U(v, config) + return rewriteValueS390X_OpLeq32U(v) case OpLeq64: - return rewriteValueS390X_OpLeq64(v, config) + return rewriteValueS390X_OpLeq64(v) case OpLeq64F: - return rewriteValueS390X_OpLeq64F(v, config) + return rewriteValueS390X_OpLeq64F(v) case OpLeq64U: - return rewriteValueS390X_OpLeq64U(v, config) + return rewriteValueS390X_OpLeq64U(v) case OpLeq8: - return rewriteValueS390X_OpLeq8(v, config) + return rewriteValueS390X_OpLeq8(v) case OpLeq8U: - return rewriteValueS390X_OpLeq8U(v, config) + return rewriteValueS390X_OpLeq8U(v) case OpLess16: - return rewriteValueS390X_OpLess16(v, config) + return rewriteValueS390X_OpLess16(v) case OpLess16U: - return rewriteValueS390X_OpLess16U(v, config) + return rewriteValueS390X_OpLess16U(v) case OpLess32: - return rewriteValueS390X_OpLess32(v, config) + return rewriteValueS390X_OpLess32(v) case OpLess32F: - return rewriteValueS390X_OpLess32F(v, config) + return rewriteValueS390X_OpLess32F(v) case OpLess32U: - return rewriteValueS390X_OpLess32U(v, config) + return rewriteValueS390X_OpLess32U(v) case OpLess64: - return rewriteValueS390X_OpLess64(v, config) + return rewriteValueS390X_OpLess64(v) case OpLess64F: - return rewriteValueS390X_OpLess64F(v, config) + return rewriteValueS390X_OpLess64F(v) case OpLess64U: - return rewriteValueS390X_OpLess64U(v, config) + return rewriteValueS390X_OpLess64U(v) case OpLess8: - return rewriteValueS390X_OpLess8(v, config) + return rewriteValueS390X_OpLess8(v) case OpLess8U: - return rewriteValueS390X_OpLess8U(v, config) + return rewriteValueS390X_OpLess8U(v) case OpLoad: - return rewriteValueS390X_OpLoad(v, config) + return rewriteValueS390X_OpLoad(v) case OpLsh16x16: - return rewriteValueS390X_OpLsh16x16(v, config) + return rewriteValueS390X_OpLsh16x16(v) case OpLsh16x32: - return rewriteValueS390X_OpLsh16x32(v, config) + return rewriteValueS390X_OpLsh16x32(v) case OpLsh16x64: - return rewriteValueS390X_OpLsh16x64(v, config) + return rewriteValueS390X_OpLsh16x64(v) case OpLsh16x8: - return rewriteValueS390X_OpLsh16x8(v, config) + return rewriteValueS390X_OpLsh16x8(v) case OpLsh32x16: - return rewriteValueS390X_OpLsh32x16(v, config) + return rewriteValueS390X_OpLsh32x16(v) case OpLsh32x32: - return rewriteValueS390X_OpLsh32x32(v, config) + return rewriteValueS390X_OpLsh32x32(v) case OpLsh32x64: - return rewriteValueS390X_OpLsh32x64(v, config) + return rewriteValueS390X_OpLsh32x64(v) case OpLsh32x8: - return rewriteValueS390X_OpLsh32x8(v, config) + return rewriteValueS390X_OpLsh32x8(v) case OpLsh64x16: - return rewriteValueS390X_OpLsh64x16(v, config) + return rewriteValueS390X_OpLsh64x16(v) case OpLsh64x32: - return rewriteValueS390X_OpLsh64x32(v, config) + return rewriteValueS390X_OpLsh64x32(v) case OpLsh64x64: - return rewriteValueS390X_OpLsh64x64(v, config) + return rewriteValueS390X_OpLsh64x64(v) case OpLsh64x8: - return rewriteValueS390X_OpLsh64x8(v, config) + return rewriteValueS390X_OpLsh64x8(v) case OpLsh8x16: - return rewriteValueS390X_OpLsh8x16(v, config) + return rewriteValueS390X_OpLsh8x16(v) case OpLsh8x32: - return rewriteValueS390X_OpLsh8x32(v, config) + return rewriteValueS390X_OpLsh8x32(v) case OpLsh8x64: - return rewriteValueS390X_OpLsh8x64(v, config) + return rewriteValueS390X_OpLsh8x64(v) case OpLsh8x8: - return rewriteValueS390X_OpLsh8x8(v, config) + return rewriteValueS390X_OpLsh8x8(v) case OpMod16: - return rewriteValueS390X_OpMod16(v, config) + return rewriteValueS390X_OpMod16(v) case OpMod16u: - return rewriteValueS390X_OpMod16u(v, config) + return rewriteValueS390X_OpMod16u(v) case OpMod32: - return rewriteValueS390X_OpMod32(v, config) + return rewriteValueS390X_OpMod32(v) case OpMod32u: - return rewriteValueS390X_OpMod32u(v, config) + return rewriteValueS390X_OpMod32u(v) case OpMod64: - return rewriteValueS390X_OpMod64(v, config) + return rewriteValueS390X_OpMod64(v) case OpMod64u: - return rewriteValueS390X_OpMod64u(v, config) + return rewriteValueS390X_OpMod64u(v) case OpMod8: - return rewriteValueS390X_OpMod8(v, config) + return rewriteValueS390X_OpMod8(v) case OpMod8u: - return rewriteValueS390X_OpMod8u(v, config) + return rewriteValueS390X_OpMod8u(v) case OpMove: - return rewriteValueS390X_OpMove(v, config) + return rewriteValueS390X_OpMove(v) case OpMul16: - return rewriteValueS390X_OpMul16(v, config) + return rewriteValueS390X_OpMul16(v) case OpMul32: - return rewriteValueS390X_OpMul32(v, config) + return rewriteValueS390X_OpMul32(v) case OpMul32F: - return rewriteValueS390X_OpMul32F(v, config) + return rewriteValueS390X_OpMul32F(v) case OpMul64: - return rewriteValueS390X_OpMul64(v, config) + return rewriteValueS390X_OpMul64(v) case OpMul64F: - return rewriteValueS390X_OpMul64F(v, config) + return rewriteValueS390X_OpMul64F(v) case OpMul8: - return rewriteValueS390X_OpMul8(v, config) + return rewriteValueS390X_OpMul8(v) case OpNeg16: - return rewriteValueS390X_OpNeg16(v, config) + return rewriteValueS390X_OpNeg16(v) case OpNeg32: - return rewriteValueS390X_OpNeg32(v, config) + return rewriteValueS390X_OpNeg32(v) case OpNeg32F: - return rewriteValueS390X_OpNeg32F(v, config) + return rewriteValueS390X_OpNeg32F(v) case OpNeg64: - return rewriteValueS390X_OpNeg64(v, config) + return rewriteValueS390X_OpNeg64(v) case OpNeg64F: - return rewriteValueS390X_OpNeg64F(v, config) + return rewriteValueS390X_OpNeg64F(v) case OpNeg8: - return rewriteValueS390X_OpNeg8(v, config) + return rewriteValueS390X_OpNeg8(v) case OpNeq16: - return rewriteValueS390X_OpNeq16(v, config) + return rewriteValueS390X_OpNeq16(v) case OpNeq32: - return rewriteValueS390X_OpNeq32(v, config) + return rewriteValueS390X_OpNeq32(v) case OpNeq32F: - return rewriteValueS390X_OpNeq32F(v, config) + return rewriteValueS390X_OpNeq32F(v) case OpNeq64: - return rewriteValueS390X_OpNeq64(v, config) + return rewriteValueS390X_OpNeq64(v) case OpNeq64F: - return rewriteValueS390X_OpNeq64F(v, config) + return rewriteValueS390X_OpNeq64F(v) case OpNeq8: - return rewriteValueS390X_OpNeq8(v, config) + return rewriteValueS390X_OpNeq8(v) case OpNeqB: - return rewriteValueS390X_OpNeqB(v, config) + return rewriteValueS390X_OpNeqB(v) case OpNeqPtr: - return rewriteValueS390X_OpNeqPtr(v, config) + return rewriteValueS390X_OpNeqPtr(v) case OpNilCheck: - return rewriteValueS390X_OpNilCheck(v, config) + return rewriteValueS390X_OpNilCheck(v) case OpNot: - return rewriteValueS390X_OpNot(v, config) + return rewriteValueS390X_OpNot(v) case OpOffPtr: - return rewriteValueS390X_OpOffPtr(v, config) + return rewriteValueS390X_OpOffPtr(v) case OpOr16: - return rewriteValueS390X_OpOr16(v, config) + return rewriteValueS390X_OpOr16(v) case OpOr32: - return rewriteValueS390X_OpOr32(v, config) + return rewriteValueS390X_OpOr32(v) case OpOr64: - return rewriteValueS390X_OpOr64(v, config) + return rewriteValueS390X_OpOr64(v) case OpOr8: - return rewriteValueS390X_OpOr8(v, config) + return rewriteValueS390X_OpOr8(v) case OpOrB: - return rewriteValueS390X_OpOrB(v, config) + return rewriteValueS390X_OpOrB(v) case OpRound32F: - return rewriteValueS390X_OpRound32F(v, config) + return rewriteValueS390X_OpRound32F(v) case OpRound64F: - return rewriteValueS390X_OpRound64F(v, config) + return rewriteValueS390X_OpRound64F(v) case OpRsh16Ux16: - return rewriteValueS390X_OpRsh16Ux16(v, config) + return rewriteValueS390X_OpRsh16Ux16(v) case OpRsh16Ux32: - return rewriteValueS390X_OpRsh16Ux32(v, config) + return rewriteValueS390X_OpRsh16Ux32(v) case OpRsh16Ux64: - return rewriteValueS390X_OpRsh16Ux64(v, config) + return rewriteValueS390X_OpRsh16Ux64(v) case OpRsh16Ux8: - return rewriteValueS390X_OpRsh16Ux8(v, config) + return rewriteValueS390X_OpRsh16Ux8(v) case OpRsh16x16: - return rewriteValueS390X_OpRsh16x16(v, config) + return rewriteValueS390X_OpRsh16x16(v) case OpRsh16x32: - return rewriteValueS390X_OpRsh16x32(v, config) + return rewriteValueS390X_OpRsh16x32(v) case OpRsh16x64: - return rewriteValueS390X_OpRsh16x64(v, config) + return rewriteValueS390X_OpRsh16x64(v) case OpRsh16x8: - return rewriteValueS390X_OpRsh16x8(v, config) + return rewriteValueS390X_OpRsh16x8(v) case OpRsh32Ux16: - return rewriteValueS390X_OpRsh32Ux16(v, config) + return rewriteValueS390X_OpRsh32Ux16(v) case OpRsh32Ux32: - return rewriteValueS390X_OpRsh32Ux32(v, config) + return rewriteValueS390X_OpRsh32Ux32(v) case OpRsh32Ux64: - return rewriteValueS390X_OpRsh32Ux64(v, config) + return rewriteValueS390X_OpRsh32Ux64(v) case OpRsh32Ux8: - return rewriteValueS390X_OpRsh32Ux8(v, config) + return rewriteValueS390X_OpRsh32Ux8(v) case OpRsh32x16: - return rewriteValueS390X_OpRsh32x16(v, config) + return rewriteValueS390X_OpRsh32x16(v) case OpRsh32x32: - return rewriteValueS390X_OpRsh32x32(v, config) + return rewriteValueS390X_OpRsh32x32(v) case OpRsh32x64: - return rewriteValueS390X_OpRsh32x64(v, config) + return rewriteValueS390X_OpRsh32x64(v) case OpRsh32x8: - return rewriteValueS390X_OpRsh32x8(v, config) + return rewriteValueS390X_OpRsh32x8(v) case OpRsh64Ux16: - return rewriteValueS390X_OpRsh64Ux16(v, config) + return rewriteValueS390X_OpRsh64Ux16(v) case OpRsh64Ux32: - return rewriteValueS390X_OpRsh64Ux32(v, config) + return rewriteValueS390X_OpRsh64Ux32(v) case OpRsh64Ux64: - return rewriteValueS390X_OpRsh64Ux64(v, config) + return rewriteValueS390X_OpRsh64Ux64(v) case OpRsh64Ux8: - return rewriteValueS390X_OpRsh64Ux8(v, config) + return rewriteValueS390X_OpRsh64Ux8(v) case OpRsh64x16: - return rewriteValueS390X_OpRsh64x16(v, config) + return rewriteValueS390X_OpRsh64x16(v) case OpRsh64x32: - return rewriteValueS390X_OpRsh64x32(v, config) + return rewriteValueS390X_OpRsh64x32(v) case OpRsh64x64: - return rewriteValueS390X_OpRsh64x64(v, config) + return rewriteValueS390X_OpRsh64x64(v) case OpRsh64x8: - return rewriteValueS390X_OpRsh64x8(v, config) + return rewriteValueS390X_OpRsh64x8(v) case OpRsh8Ux16: - return rewriteValueS390X_OpRsh8Ux16(v, config) + return rewriteValueS390X_OpRsh8Ux16(v) case OpRsh8Ux32: - return rewriteValueS390X_OpRsh8Ux32(v, config) + return rewriteValueS390X_OpRsh8Ux32(v) case OpRsh8Ux64: - return rewriteValueS390X_OpRsh8Ux64(v, config) + return rewriteValueS390X_OpRsh8Ux64(v) case OpRsh8Ux8: - return rewriteValueS390X_OpRsh8Ux8(v, config) + return rewriteValueS390X_OpRsh8Ux8(v) case OpRsh8x16: - return rewriteValueS390X_OpRsh8x16(v, config) + return rewriteValueS390X_OpRsh8x16(v) case OpRsh8x32: - return rewriteValueS390X_OpRsh8x32(v, config) + return rewriteValueS390X_OpRsh8x32(v) case OpRsh8x64: - return rewriteValueS390X_OpRsh8x64(v, config) + return rewriteValueS390X_OpRsh8x64(v) case OpRsh8x8: - return rewriteValueS390X_OpRsh8x8(v, config) + return rewriteValueS390X_OpRsh8x8(v) case OpS390XADD: - return rewriteValueS390X_OpS390XADD(v, config) + return rewriteValueS390X_OpS390XADD(v) case OpS390XADDW: - return rewriteValueS390X_OpS390XADDW(v, config) + return rewriteValueS390X_OpS390XADDW(v) case OpS390XADDWconst: - return rewriteValueS390X_OpS390XADDWconst(v, config) + return rewriteValueS390X_OpS390XADDWconst(v) case OpS390XADDconst: - return rewriteValueS390X_OpS390XADDconst(v, config) + return rewriteValueS390X_OpS390XADDconst(v) case OpS390XAND: - return rewriteValueS390X_OpS390XAND(v, config) + return rewriteValueS390X_OpS390XAND(v) case OpS390XANDW: - return rewriteValueS390X_OpS390XANDW(v, config) + return rewriteValueS390X_OpS390XANDW(v) case OpS390XANDWconst: - return rewriteValueS390X_OpS390XANDWconst(v, config) + return rewriteValueS390X_OpS390XANDWconst(v) case OpS390XANDconst: - return rewriteValueS390X_OpS390XANDconst(v, config) + return rewriteValueS390X_OpS390XANDconst(v) case OpS390XCMP: - return rewriteValueS390X_OpS390XCMP(v, config) + return rewriteValueS390X_OpS390XCMP(v) case OpS390XCMPU: - return rewriteValueS390X_OpS390XCMPU(v, config) + return rewriteValueS390X_OpS390XCMPU(v) case OpS390XCMPUconst: - return rewriteValueS390X_OpS390XCMPUconst(v, config) + return rewriteValueS390X_OpS390XCMPUconst(v) case OpS390XCMPW: - return rewriteValueS390X_OpS390XCMPW(v, config) + return rewriteValueS390X_OpS390XCMPW(v) case OpS390XCMPWU: - return rewriteValueS390X_OpS390XCMPWU(v, config) + return rewriteValueS390X_OpS390XCMPWU(v) case OpS390XCMPWUconst: - return rewriteValueS390X_OpS390XCMPWUconst(v, config) + return rewriteValueS390X_OpS390XCMPWUconst(v) case OpS390XCMPWconst: - return rewriteValueS390X_OpS390XCMPWconst(v, config) + return rewriteValueS390X_OpS390XCMPWconst(v) case OpS390XCMPconst: - return rewriteValueS390X_OpS390XCMPconst(v, config) + return rewriteValueS390X_OpS390XCMPconst(v) case OpS390XFADD: - return rewriteValueS390X_OpS390XFADD(v, config) + return rewriteValueS390X_OpS390XFADD(v) case OpS390XFADDS: - return rewriteValueS390X_OpS390XFADDS(v, config) + return rewriteValueS390X_OpS390XFADDS(v) case OpS390XFMOVDload: - return rewriteValueS390X_OpS390XFMOVDload(v, config) + return rewriteValueS390X_OpS390XFMOVDload(v) case OpS390XFMOVDloadidx: - return rewriteValueS390X_OpS390XFMOVDloadidx(v, config) + return rewriteValueS390X_OpS390XFMOVDloadidx(v) case OpS390XFMOVDstore: - return rewriteValueS390X_OpS390XFMOVDstore(v, config) + return rewriteValueS390X_OpS390XFMOVDstore(v) case OpS390XFMOVDstoreidx: - return rewriteValueS390X_OpS390XFMOVDstoreidx(v, config) + return rewriteValueS390X_OpS390XFMOVDstoreidx(v) case OpS390XFMOVSload: - return rewriteValueS390X_OpS390XFMOVSload(v, config) + return rewriteValueS390X_OpS390XFMOVSload(v) case OpS390XFMOVSloadidx: - return rewriteValueS390X_OpS390XFMOVSloadidx(v, config) + return rewriteValueS390X_OpS390XFMOVSloadidx(v) case OpS390XFMOVSstore: - return rewriteValueS390X_OpS390XFMOVSstore(v, config) + return rewriteValueS390X_OpS390XFMOVSstore(v) case OpS390XFMOVSstoreidx: - return rewriteValueS390X_OpS390XFMOVSstoreidx(v, config) + return rewriteValueS390X_OpS390XFMOVSstoreidx(v) case OpS390XFSUB: - return rewriteValueS390X_OpS390XFSUB(v, config) + return rewriteValueS390X_OpS390XFSUB(v) case OpS390XFSUBS: - return rewriteValueS390X_OpS390XFSUBS(v, config) + return rewriteValueS390X_OpS390XFSUBS(v) case OpS390XLoweredRound32F: - return rewriteValueS390X_OpS390XLoweredRound32F(v, config) + return rewriteValueS390X_OpS390XLoweredRound32F(v) case OpS390XLoweredRound64F: - return rewriteValueS390X_OpS390XLoweredRound64F(v, config) + return rewriteValueS390X_OpS390XLoweredRound64F(v) case OpS390XMOVBZload: - return rewriteValueS390X_OpS390XMOVBZload(v, config) + return rewriteValueS390X_OpS390XMOVBZload(v) case OpS390XMOVBZloadidx: - return rewriteValueS390X_OpS390XMOVBZloadidx(v, config) + return rewriteValueS390X_OpS390XMOVBZloadidx(v) case OpS390XMOVBZreg: - return rewriteValueS390X_OpS390XMOVBZreg(v, config) + return rewriteValueS390X_OpS390XMOVBZreg(v) case OpS390XMOVBload: - return rewriteValueS390X_OpS390XMOVBload(v, config) + return rewriteValueS390X_OpS390XMOVBload(v) case OpS390XMOVBreg: - return rewriteValueS390X_OpS390XMOVBreg(v, config) + return rewriteValueS390X_OpS390XMOVBreg(v) case OpS390XMOVBstore: - return rewriteValueS390X_OpS390XMOVBstore(v, config) + return rewriteValueS390X_OpS390XMOVBstore(v) case OpS390XMOVBstoreconst: - return rewriteValueS390X_OpS390XMOVBstoreconst(v, config) + return rewriteValueS390X_OpS390XMOVBstoreconst(v) case OpS390XMOVBstoreidx: - return rewriteValueS390X_OpS390XMOVBstoreidx(v, config) + return rewriteValueS390X_OpS390XMOVBstoreidx(v) case OpS390XMOVDEQ: - return rewriteValueS390X_OpS390XMOVDEQ(v, config) + return rewriteValueS390X_OpS390XMOVDEQ(v) case OpS390XMOVDGE: - return rewriteValueS390X_OpS390XMOVDGE(v, config) + return rewriteValueS390X_OpS390XMOVDGE(v) case OpS390XMOVDGT: - return rewriteValueS390X_OpS390XMOVDGT(v, config) + return rewriteValueS390X_OpS390XMOVDGT(v) case OpS390XMOVDLE: - return rewriteValueS390X_OpS390XMOVDLE(v, config) + return rewriteValueS390X_OpS390XMOVDLE(v) case OpS390XMOVDLT: - return rewriteValueS390X_OpS390XMOVDLT(v, config) + return rewriteValueS390X_OpS390XMOVDLT(v) case OpS390XMOVDNE: - return rewriteValueS390X_OpS390XMOVDNE(v, config) + return rewriteValueS390X_OpS390XMOVDNE(v) case OpS390XMOVDaddridx: - return rewriteValueS390X_OpS390XMOVDaddridx(v, config) + return rewriteValueS390X_OpS390XMOVDaddridx(v) case OpS390XMOVDload: - return rewriteValueS390X_OpS390XMOVDload(v, config) + return rewriteValueS390X_OpS390XMOVDload(v) case OpS390XMOVDloadidx: - return rewriteValueS390X_OpS390XMOVDloadidx(v, config) + return rewriteValueS390X_OpS390XMOVDloadidx(v) case OpS390XMOVDnop: - return rewriteValueS390X_OpS390XMOVDnop(v, config) + return rewriteValueS390X_OpS390XMOVDnop(v) case OpS390XMOVDreg: - return rewriteValueS390X_OpS390XMOVDreg(v, config) + return rewriteValueS390X_OpS390XMOVDreg(v) case OpS390XMOVDstore: - return rewriteValueS390X_OpS390XMOVDstore(v, config) + return rewriteValueS390X_OpS390XMOVDstore(v) case OpS390XMOVDstoreconst: - return rewriteValueS390X_OpS390XMOVDstoreconst(v, config) + return rewriteValueS390X_OpS390XMOVDstoreconst(v) case OpS390XMOVDstoreidx: - return rewriteValueS390X_OpS390XMOVDstoreidx(v, config) + return rewriteValueS390X_OpS390XMOVDstoreidx(v) case OpS390XMOVHBRstore: - return rewriteValueS390X_OpS390XMOVHBRstore(v, config) + return rewriteValueS390X_OpS390XMOVHBRstore(v) case OpS390XMOVHBRstoreidx: - return rewriteValueS390X_OpS390XMOVHBRstoreidx(v, config) + return rewriteValueS390X_OpS390XMOVHBRstoreidx(v) case OpS390XMOVHZload: - return rewriteValueS390X_OpS390XMOVHZload(v, config) + return rewriteValueS390X_OpS390XMOVHZload(v) case OpS390XMOVHZloadidx: - return rewriteValueS390X_OpS390XMOVHZloadidx(v, config) + return rewriteValueS390X_OpS390XMOVHZloadidx(v) case OpS390XMOVHZreg: - return rewriteValueS390X_OpS390XMOVHZreg(v, config) + return rewriteValueS390X_OpS390XMOVHZreg(v) case OpS390XMOVHload: - return rewriteValueS390X_OpS390XMOVHload(v, config) + return rewriteValueS390X_OpS390XMOVHload(v) case OpS390XMOVHreg: - return rewriteValueS390X_OpS390XMOVHreg(v, config) + return rewriteValueS390X_OpS390XMOVHreg(v) case OpS390XMOVHstore: - return rewriteValueS390X_OpS390XMOVHstore(v, config) + return rewriteValueS390X_OpS390XMOVHstore(v) case OpS390XMOVHstoreconst: - return rewriteValueS390X_OpS390XMOVHstoreconst(v, config) + return rewriteValueS390X_OpS390XMOVHstoreconst(v) case OpS390XMOVHstoreidx: - return rewriteValueS390X_OpS390XMOVHstoreidx(v, config) + return rewriteValueS390X_OpS390XMOVHstoreidx(v) case OpS390XMOVWBRstore: - return rewriteValueS390X_OpS390XMOVWBRstore(v, config) + return rewriteValueS390X_OpS390XMOVWBRstore(v) case OpS390XMOVWBRstoreidx: - return rewriteValueS390X_OpS390XMOVWBRstoreidx(v, config) + return rewriteValueS390X_OpS390XMOVWBRstoreidx(v) case OpS390XMOVWZload: - return rewriteValueS390X_OpS390XMOVWZload(v, config) + return rewriteValueS390X_OpS390XMOVWZload(v) case OpS390XMOVWZloadidx: - return rewriteValueS390X_OpS390XMOVWZloadidx(v, config) + return rewriteValueS390X_OpS390XMOVWZloadidx(v) case OpS390XMOVWZreg: - return rewriteValueS390X_OpS390XMOVWZreg(v, config) + return rewriteValueS390X_OpS390XMOVWZreg(v) case OpS390XMOVWload: - return rewriteValueS390X_OpS390XMOVWload(v, config) + return rewriteValueS390X_OpS390XMOVWload(v) case OpS390XMOVWreg: - return rewriteValueS390X_OpS390XMOVWreg(v, config) + return rewriteValueS390X_OpS390XMOVWreg(v) case OpS390XMOVWstore: - return rewriteValueS390X_OpS390XMOVWstore(v, config) + return rewriteValueS390X_OpS390XMOVWstore(v) case OpS390XMOVWstoreconst: - return rewriteValueS390X_OpS390XMOVWstoreconst(v, config) + return rewriteValueS390X_OpS390XMOVWstoreconst(v) case OpS390XMOVWstoreidx: - return rewriteValueS390X_OpS390XMOVWstoreidx(v, config) + return rewriteValueS390X_OpS390XMOVWstoreidx(v) case OpS390XMULLD: - return rewriteValueS390X_OpS390XMULLD(v, config) + return rewriteValueS390X_OpS390XMULLD(v) case OpS390XMULLDconst: - return rewriteValueS390X_OpS390XMULLDconst(v, config) + return rewriteValueS390X_OpS390XMULLDconst(v) case OpS390XMULLW: - return rewriteValueS390X_OpS390XMULLW(v, config) + return rewriteValueS390X_OpS390XMULLW(v) case OpS390XMULLWconst: - return rewriteValueS390X_OpS390XMULLWconst(v, config) + return rewriteValueS390X_OpS390XMULLWconst(v) case OpS390XNEG: - return rewriteValueS390X_OpS390XNEG(v, config) + return rewriteValueS390X_OpS390XNEG(v) case OpS390XNEGW: - return rewriteValueS390X_OpS390XNEGW(v, config) + return rewriteValueS390X_OpS390XNEGW(v) case OpS390XNOT: - return rewriteValueS390X_OpS390XNOT(v, config) + return rewriteValueS390X_OpS390XNOT(v) case OpS390XNOTW: - return rewriteValueS390X_OpS390XNOTW(v, config) + return rewriteValueS390X_OpS390XNOTW(v) case OpS390XOR: - return rewriteValueS390X_OpS390XOR(v, config) + return rewriteValueS390X_OpS390XOR(v) case OpS390XORW: - return rewriteValueS390X_OpS390XORW(v, config) + return rewriteValueS390X_OpS390XORW(v) case OpS390XORWconst: - return rewriteValueS390X_OpS390XORWconst(v, config) + return rewriteValueS390X_OpS390XORWconst(v) case OpS390XORconst: - return rewriteValueS390X_OpS390XORconst(v, config) + return rewriteValueS390X_OpS390XORconst(v) case OpS390XSLD: - return rewriteValueS390X_OpS390XSLD(v, config) + return rewriteValueS390X_OpS390XSLD(v) case OpS390XSLW: - return rewriteValueS390X_OpS390XSLW(v, config) + return rewriteValueS390X_OpS390XSLW(v) case OpS390XSRAD: - return rewriteValueS390X_OpS390XSRAD(v, config) + return rewriteValueS390X_OpS390XSRAD(v) case OpS390XSRADconst: - return rewriteValueS390X_OpS390XSRADconst(v, config) + return rewriteValueS390X_OpS390XSRADconst(v) case OpS390XSRAW: - return rewriteValueS390X_OpS390XSRAW(v, config) + return rewriteValueS390X_OpS390XSRAW(v) case OpS390XSRAWconst: - return rewriteValueS390X_OpS390XSRAWconst(v, config) + return rewriteValueS390X_OpS390XSRAWconst(v) case OpS390XSRD: - return rewriteValueS390X_OpS390XSRD(v, config) + return rewriteValueS390X_OpS390XSRD(v) case OpS390XSRW: - return rewriteValueS390X_OpS390XSRW(v, config) + return rewriteValueS390X_OpS390XSRW(v) case OpS390XSTM2: - return rewriteValueS390X_OpS390XSTM2(v, config) + return rewriteValueS390X_OpS390XSTM2(v) case OpS390XSTMG2: - return rewriteValueS390X_OpS390XSTMG2(v, config) + return rewriteValueS390X_OpS390XSTMG2(v) case OpS390XSUB: - return rewriteValueS390X_OpS390XSUB(v, config) + return rewriteValueS390X_OpS390XSUB(v) case OpS390XSUBEWcarrymask: - return rewriteValueS390X_OpS390XSUBEWcarrymask(v, config) + return rewriteValueS390X_OpS390XSUBEWcarrymask(v) case OpS390XSUBEcarrymask: - return rewriteValueS390X_OpS390XSUBEcarrymask(v, config) + return rewriteValueS390X_OpS390XSUBEcarrymask(v) case OpS390XSUBW: - return rewriteValueS390X_OpS390XSUBW(v, config) + return rewriteValueS390X_OpS390XSUBW(v) case OpS390XSUBWconst: - return rewriteValueS390X_OpS390XSUBWconst(v, config) + return rewriteValueS390X_OpS390XSUBWconst(v) case OpS390XSUBconst: - return rewriteValueS390X_OpS390XSUBconst(v, config) + return rewriteValueS390X_OpS390XSUBconst(v) case OpS390XXOR: - return rewriteValueS390X_OpS390XXOR(v, config) + return rewriteValueS390X_OpS390XXOR(v) case OpS390XXORW: - return rewriteValueS390X_OpS390XXORW(v, config) + return rewriteValueS390X_OpS390XXORW(v) case OpS390XXORWconst: - return rewriteValueS390X_OpS390XXORWconst(v, config) + return rewriteValueS390X_OpS390XXORWconst(v) case OpS390XXORconst: - return rewriteValueS390X_OpS390XXORconst(v, config) + return rewriteValueS390X_OpS390XXORconst(v) case OpSelect0: - return rewriteValueS390X_OpSelect0(v, config) + return rewriteValueS390X_OpSelect0(v) case OpSelect1: - return rewriteValueS390X_OpSelect1(v, config) + return rewriteValueS390X_OpSelect1(v) case OpSignExt16to32: - return rewriteValueS390X_OpSignExt16to32(v, config) + return rewriteValueS390X_OpSignExt16to32(v) case OpSignExt16to64: - return rewriteValueS390X_OpSignExt16to64(v, config) + return rewriteValueS390X_OpSignExt16to64(v) case OpSignExt32to64: - return rewriteValueS390X_OpSignExt32to64(v, config) + return rewriteValueS390X_OpSignExt32to64(v) case OpSignExt8to16: - return rewriteValueS390X_OpSignExt8to16(v, config) + return rewriteValueS390X_OpSignExt8to16(v) case OpSignExt8to32: - return rewriteValueS390X_OpSignExt8to32(v, config) + return rewriteValueS390X_OpSignExt8to32(v) case OpSignExt8to64: - return rewriteValueS390X_OpSignExt8to64(v, config) + return rewriteValueS390X_OpSignExt8to64(v) case OpSlicemask: - return rewriteValueS390X_OpSlicemask(v, config) + return rewriteValueS390X_OpSlicemask(v) case OpSqrt: - return rewriteValueS390X_OpSqrt(v, config) + return rewriteValueS390X_OpSqrt(v) case OpStaticCall: - return rewriteValueS390X_OpStaticCall(v, config) + return rewriteValueS390X_OpStaticCall(v) case OpStore: - return rewriteValueS390X_OpStore(v, config) + return rewriteValueS390X_OpStore(v) case OpSub16: - return rewriteValueS390X_OpSub16(v, config) + return rewriteValueS390X_OpSub16(v) case OpSub32: - return rewriteValueS390X_OpSub32(v, config) + return rewriteValueS390X_OpSub32(v) case OpSub32F: - return rewriteValueS390X_OpSub32F(v, config) + return rewriteValueS390X_OpSub32F(v) case OpSub64: - return rewriteValueS390X_OpSub64(v, config) + return rewriteValueS390X_OpSub64(v) case OpSub64F: - return rewriteValueS390X_OpSub64F(v, config) + return rewriteValueS390X_OpSub64F(v) case OpSub8: - return rewriteValueS390X_OpSub8(v, config) + return rewriteValueS390X_OpSub8(v) case OpSubPtr: - return rewriteValueS390X_OpSubPtr(v, config) + return rewriteValueS390X_OpSubPtr(v) case OpTrunc16to8: - return rewriteValueS390X_OpTrunc16to8(v, config) + return rewriteValueS390X_OpTrunc16to8(v) case OpTrunc32to16: - return rewriteValueS390X_OpTrunc32to16(v, config) + return rewriteValueS390X_OpTrunc32to16(v) case OpTrunc32to8: - return rewriteValueS390X_OpTrunc32to8(v, config) + return rewriteValueS390X_OpTrunc32to8(v) case OpTrunc64to16: - return rewriteValueS390X_OpTrunc64to16(v, config) + return rewriteValueS390X_OpTrunc64to16(v) case OpTrunc64to32: - return rewriteValueS390X_OpTrunc64to32(v, config) + return rewriteValueS390X_OpTrunc64to32(v) case OpTrunc64to8: - return rewriteValueS390X_OpTrunc64to8(v, config) + return rewriteValueS390X_OpTrunc64to8(v) case OpXor16: - return rewriteValueS390X_OpXor16(v, config) + return rewriteValueS390X_OpXor16(v) case OpXor32: - return rewriteValueS390X_OpXor32(v, config) + return rewriteValueS390X_OpXor32(v) case OpXor64: - return rewriteValueS390X_OpXor64(v, config) + return rewriteValueS390X_OpXor64(v) case OpXor8: - return rewriteValueS390X_OpXor8(v, config) + return rewriteValueS390X_OpXor8(v) case OpZero: - return rewriteValueS390X_OpZero(v, config) + return rewriteValueS390X_OpZero(v) case OpZeroExt16to32: - return rewriteValueS390X_OpZeroExt16to32(v, config) + return rewriteValueS390X_OpZeroExt16to32(v) case OpZeroExt16to64: - return rewriteValueS390X_OpZeroExt16to64(v, config) + return rewriteValueS390X_OpZeroExt16to64(v) case OpZeroExt32to64: - return rewriteValueS390X_OpZeroExt32to64(v, config) + return rewriteValueS390X_OpZeroExt32to64(v) case OpZeroExt8to16: - return rewriteValueS390X_OpZeroExt8to16(v, config) + return rewriteValueS390X_OpZeroExt8to16(v) case OpZeroExt8to32: - return rewriteValueS390X_OpZeroExt8to32(v, config) + return rewriteValueS390X_OpZeroExt8to32(v) case OpZeroExt8to64: - return rewriteValueS390X_OpZeroExt8to64(v, config) + return rewriteValueS390X_OpZeroExt8to64(v) } return false } -func rewriteValueS390X_OpAdd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAdd16(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADDW x y) @@ -730,9 +728,7 @@ func rewriteValueS390X_OpAdd16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAdd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAdd32(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADDW x y) @@ -745,9 +741,7 @@ func rewriteValueS390X_OpAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAdd32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAdd32F(v *Value) bool { // match: (Add32F x y) // cond: // result: (FADDS x y) @@ -760,9 +754,7 @@ func rewriteValueS390X_OpAdd32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAdd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAdd64(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADD x y) @@ -775,9 +767,7 @@ func rewriteValueS390X_OpAdd64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAdd64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAdd64F(v *Value) bool { // match: (Add64F x y) // cond: // result: (FADD x y) @@ -790,9 +780,7 @@ func rewriteValueS390X_OpAdd64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAdd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAdd8(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADDW x y) @@ -805,9 +793,7 @@ func rewriteValueS390X_OpAdd8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAddPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAddPtr(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -820,9 +806,7 @@ func rewriteValueS390X_OpAddPtr(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAddr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAddr(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVDaddr {sym} base) @@ -835,9 +819,7 @@ func rewriteValueS390X_OpAddr(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAnd16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAnd16(v *Value) bool { // match: (And16 x y) // cond: // result: (ANDW x y) @@ -850,9 +832,7 @@ func rewriteValueS390X_OpAnd16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAnd32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAnd32(v *Value) bool { // match: (And32 x y) // cond: // result: (ANDW x y) @@ -865,9 +845,7 @@ func rewriteValueS390X_OpAnd32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAnd64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAnd64(v *Value) bool { // match: (And64 x y) // cond: // result: (AND x y) @@ -880,9 +858,7 @@ func rewriteValueS390X_OpAnd64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAnd8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAnd8(v *Value) bool { // match: (And8 x y) // cond: // result: (ANDW x y) @@ -895,9 +871,7 @@ func rewriteValueS390X_OpAnd8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAndB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAndB(v *Value) bool { // match: (AndB x y) // cond: // result: (ANDW x y) @@ -910,9 +884,13 @@ func rewriteValueS390X_OpAndB(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicAdd32(v *Value, config *Config) bool { +func rewriteValueS390X_OpAtomicAdd32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (AtomicAdd32 ptr val mem) // cond: // result: (AddTupleFirst32 (LAA ptr val mem) val) @@ -921,7 +899,7 @@ func rewriteValueS390X_OpAtomicAdd32(v *Value, config *Config) bool { val := v.Args[1] mem := v.Args[2] v.reset(OpS390XAddTupleFirst32) - v0 := b.NewValue0(v.Pos, OpS390XLAA, MakeTuple(config.fe.TypeUInt32(), TypeMem)) + v0 := b.NewValue0(v.Pos, OpS390XLAA, MakeTuple(fe.TypeUInt32(), TypeMem)) v0.AddArg(ptr) v0.AddArg(val) v0.AddArg(mem) @@ -930,9 +908,13 @@ func rewriteValueS390X_OpAtomicAdd32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicAdd64(v *Value, config *Config) bool { +func rewriteValueS390X_OpAtomicAdd64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (AtomicAdd64 ptr val mem) // cond: // result: (AddTupleFirst64 (LAAG ptr val mem) val) @@ -941,7 +923,7 @@ func rewriteValueS390X_OpAtomicAdd64(v *Value, config *Config) bool { val := v.Args[1] mem := v.Args[2] v.reset(OpS390XAddTupleFirst64) - v0 := b.NewValue0(v.Pos, OpS390XLAAG, MakeTuple(config.fe.TypeUInt64(), TypeMem)) + v0 := b.NewValue0(v.Pos, OpS390XLAAG, MakeTuple(fe.TypeUInt64(), TypeMem)) v0.AddArg(ptr) v0.AddArg(val) v0.AddArg(mem) @@ -950,9 +932,7 @@ func rewriteValueS390X_OpAtomicAdd64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (LoweredAtomicCas32 ptr old new_ mem) @@ -969,9 +949,7 @@ func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value) bool { // match: (AtomicCompareAndSwap64 ptr old new_ mem) // cond: // result: (LoweredAtomicCas64 ptr old new_ mem) @@ -988,9 +966,7 @@ func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicExchange32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicExchange32(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (LoweredAtomicExchange32 ptr val mem) @@ -1005,9 +981,7 @@ func rewriteValueS390X_OpAtomicExchange32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicExchange64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicExchange64(v *Value) bool { // match: (AtomicExchange64 ptr val mem) // cond: // result: (LoweredAtomicExchange64 ptr val mem) @@ -1022,9 +996,7 @@ func rewriteValueS390X_OpAtomicExchange64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicLoad32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicLoad32(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (MOVWZatomicload ptr mem) @@ -1037,9 +1009,7 @@ func rewriteValueS390X_OpAtomicLoad32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicLoad64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicLoad64(v *Value) bool { // match: (AtomicLoad64 ptr mem) // cond: // result: (MOVDatomicload ptr mem) @@ -1052,9 +1022,7 @@ func rewriteValueS390X_OpAtomicLoad64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicLoadPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicLoadPtr(v *Value) bool { // match: (AtomicLoadPtr ptr mem) // cond: // result: (MOVDatomicload ptr mem) @@ -1067,9 +1035,7 @@ func rewriteValueS390X_OpAtomicLoadPtr(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicStore32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicStore32(v *Value) bool { // match: (AtomicStore32 ptr val mem) // cond: // result: (MOVWatomicstore ptr val mem) @@ -1084,9 +1050,7 @@ func rewriteValueS390X_OpAtomicStore32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicStore64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicStore64(v *Value) bool { // match: (AtomicStore64 ptr val mem) // cond: // result: (MOVDatomicstore ptr val mem) @@ -1101,9 +1065,7 @@ func rewriteValueS390X_OpAtomicStore64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value) bool { // match: (AtomicStorePtrNoWB ptr val mem) // cond: // result: (MOVDatomicstore ptr val mem) @@ -1118,7 +1080,7 @@ func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpAvg64u(v *Value, config *Config) bool { +func rewriteValueS390X_OpAvg64u(v *Value) bool { b := v.Block _ = b // match: (Avg64u <t> x y) @@ -1140,27 +1102,29 @@ func rewriteValueS390X_OpAvg64u(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpBitLen64(v *Value, config *Config) bool { +func rewriteValueS390X_OpBitLen64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (BitLen64 x) // cond: // result: (SUB (MOVDconst [64]) (FLOGR x)) for { x := v.Args[0] v.reset(OpS390XSUB) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 64 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XFLOGR, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XFLOGR, fe.TypeUInt64()) v1.AddArg(x) v.AddArg(v1) return true } } -func rewriteValueS390X_OpBswap32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpBswap32(v *Value) bool { // match: (Bswap32 x) // cond: // result: (MOVWBR x) @@ -1171,9 +1135,7 @@ func rewriteValueS390X_OpBswap32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpBswap64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpBswap64(v *Value) bool { // match: (Bswap64 x) // cond: // result: (MOVDBR x) @@ -1184,9 +1146,7 @@ func rewriteValueS390X_OpBswap64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpClosureCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpClosureCall(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -1203,9 +1163,7 @@ func rewriteValueS390X_OpClosureCall(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCom16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCom16(v *Value) bool { // match: (Com16 x) // cond: // result: (NOTW x) @@ -1216,9 +1174,7 @@ func rewriteValueS390X_OpCom16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCom32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCom32(v *Value) bool { // match: (Com32 x) // cond: // result: (NOTW x) @@ -1229,9 +1185,7 @@ func rewriteValueS390X_OpCom32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCom64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCom64(v *Value) bool { // match: (Com64 x) // cond: // result: (NOT x) @@ -1242,9 +1196,7 @@ func rewriteValueS390X_OpCom64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCom8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCom8(v *Value) bool { // match: (Com8 x) // cond: // result: (NOTW x) @@ -1255,9 +1207,7 @@ func rewriteValueS390X_OpCom8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpConst16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpConst16(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVDconst [val]) @@ -1268,9 +1218,7 @@ func rewriteValueS390X_OpConst16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpConst32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpConst32(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVDconst [val]) @@ -1281,9 +1229,7 @@ func rewriteValueS390X_OpConst32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpConst32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpConst32F(v *Value) bool { // match: (Const32F [val]) // cond: // result: (FMOVSconst [val]) @@ -1294,9 +1240,7 @@ func rewriteValueS390X_OpConst32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpConst64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpConst64(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVDconst [val]) @@ -1307,9 +1251,7 @@ func rewriteValueS390X_OpConst64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpConst64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpConst64F(v *Value) bool { // match: (Const64F [val]) // cond: // result: (FMOVDconst [val]) @@ -1320,9 +1262,7 @@ func rewriteValueS390X_OpConst64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpConst8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpConst8(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVDconst [val]) @@ -1333,9 +1273,7 @@ func rewriteValueS390X_OpConst8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpConstBool(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpConstBool(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVDconst [b]) @@ -1346,9 +1284,7 @@ func rewriteValueS390X_OpConstBool(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpConstNil(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpConstNil(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVDconst [0]) @@ -1358,9 +1294,7 @@ func rewriteValueS390X_OpConstNil(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpConvert(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpConvert(v *Value) bool { // match: (Convert <t> x mem) // cond: // result: (MOVDconvert <t> x mem) @@ -1375,9 +1309,13 @@ func rewriteValueS390X_OpConvert(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCtz32(v *Value, config *Config) bool { +func rewriteValueS390X_OpCtz32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Ctz32 <t> x) // cond: // result: (SUB (MOVDconst [64]) (FLOGR (MOVWZreg (ANDW <t> (SUBWconst <t> [1] x) (NOTW <t> x))))) @@ -1385,11 +1323,11 @@ func rewriteValueS390X_OpCtz32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] v.reset(OpS390XSUB) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 64 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XFLOGR, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XFLOGR, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64()) v3 := b.NewValue0(v.Pos, OpS390XANDW, t) v4 := b.NewValue0(v.Pos, OpS390XSUBWconst, t) v4.AuxInt = 1 @@ -1404,9 +1342,13 @@ func rewriteValueS390X_OpCtz32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCtz64(v *Value, config *Config) bool { +func rewriteValueS390X_OpCtz64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Ctz64 <t> x) // cond: // result: (SUB (MOVDconst [64]) (FLOGR (AND <t> (SUBconst <t> [1] x) (NOT <t> x)))) @@ -1414,10 +1356,10 @@ func rewriteValueS390X_OpCtz64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] v.reset(OpS390XSUB) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 64 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XFLOGR, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XFLOGR, fe.TypeUInt64()) v2 := b.NewValue0(v.Pos, OpS390XAND, t) v3 := b.NewValue0(v.Pos, OpS390XSUBconst, t) v3.AuxInt = 1 @@ -1431,9 +1373,7 @@ func rewriteValueS390X_OpCtz64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt32Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt32Fto32(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (CFEBRA x) @@ -1444,9 +1384,7 @@ func rewriteValueS390X_OpCvt32Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt32Fto64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt32Fto64(v *Value) bool { // match: (Cvt32Fto64 x) // cond: // result: (CGEBRA x) @@ -1457,9 +1395,7 @@ func rewriteValueS390X_OpCvt32Fto64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt32Fto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt32Fto64F(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (LDEBR x) @@ -1470,9 +1406,7 @@ func rewriteValueS390X_OpCvt32Fto64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt32to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt32to32F(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (CEFBRA x) @@ -1483,9 +1417,7 @@ func rewriteValueS390X_OpCvt32to32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt32to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt32to64F(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (CDFBRA x) @@ -1496,9 +1428,7 @@ func rewriteValueS390X_OpCvt32to64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt64Fto32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt64Fto32(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (CFDBRA x) @@ -1509,9 +1439,7 @@ func rewriteValueS390X_OpCvt64Fto32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt64Fto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt64Fto32F(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (LEDBR x) @@ -1522,9 +1450,7 @@ func rewriteValueS390X_OpCvt64Fto32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt64Fto64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt64Fto64(v *Value) bool { // match: (Cvt64Fto64 x) // cond: // result: (CGDBRA x) @@ -1535,9 +1461,7 @@ func rewriteValueS390X_OpCvt64Fto64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt64to32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt64to32F(v *Value) bool { // match: (Cvt64to32F x) // cond: // result: (CEGBRA x) @@ -1548,9 +1472,7 @@ func rewriteValueS390X_OpCvt64to32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpCvt64to64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpCvt64to64F(v *Value) bool { // match: (Cvt64to64F x) // cond: // result: (CDGBRA x) @@ -1561,9 +1483,13 @@ func rewriteValueS390X_OpCvt64to64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpDiv16(v *Value, config *Config) bool { +func rewriteValueS390X_OpDiv16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16 x y) // cond: // result: (DIVW (MOVHreg x) (MOVHreg y)) @@ -1571,18 +1497,22 @@ func rewriteValueS390X_OpDiv16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XDIVW) - v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueS390X_OpDiv16u(v *Value, config *Config) bool { +func rewriteValueS390X_OpDiv16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16u x y) // cond: // result: (DIVWU (MOVHZreg x) (MOVHZreg y)) @@ -1590,18 +1520,22 @@ func rewriteValueS390X_OpDiv16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XDIVWU) - v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueS390X_OpDiv32(v *Value, config *Config) bool { +func rewriteValueS390X_OpDiv32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32 x y) // cond: // result: (DIVW (MOVWreg x) y) @@ -1609,16 +1543,14 @@ func rewriteValueS390X_OpDiv32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XDIVW) - v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v.AddArg(y) return true } } -func rewriteValueS390X_OpDiv32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpDiv32F(v *Value) bool { // match: (Div32F x y) // cond: // result: (FDIVS x y) @@ -1631,9 +1563,13 @@ func rewriteValueS390X_OpDiv32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpDiv32u(v *Value, config *Config) bool { +func rewriteValueS390X_OpDiv32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32u x y) // cond: // result: (DIVWU (MOVWZreg x) y) @@ -1641,16 +1577,14 @@ func rewriteValueS390X_OpDiv32u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XDIVWU) - v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) v.AddArg(y) return true } } -func rewriteValueS390X_OpDiv64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpDiv64(v *Value) bool { // match: (Div64 x y) // cond: // result: (DIVD x y) @@ -1663,9 +1597,7 @@ func rewriteValueS390X_OpDiv64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpDiv64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpDiv64F(v *Value) bool { // match: (Div64F x y) // cond: // result: (FDIV x y) @@ -1678,9 +1610,7 @@ func rewriteValueS390X_OpDiv64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpDiv64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpDiv64u(v *Value) bool { // match: (Div64u x y) // cond: // result: (DIVDU x y) @@ -1693,9 +1623,13 @@ func rewriteValueS390X_OpDiv64u(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpDiv8(v *Value, config *Config) bool { +func rewriteValueS390X_OpDiv8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8 x y) // cond: // result: (DIVW (MOVBreg x) (MOVBreg y)) @@ -1703,18 +1637,22 @@ func rewriteValueS390X_OpDiv8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XDIVW) - v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueS390X_OpDiv8u(v *Value, config *Config) bool { +func rewriteValueS390X_OpDiv8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8u x y) // cond: // result: (DIVWU (MOVBZreg x) (MOVBZreg y)) @@ -1722,18 +1660,22 @@ func rewriteValueS390X_OpDiv8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XDIVWU) - v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueS390X_OpEq16(v *Value, config *Config) bool { +func rewriteValueS390X_OpEq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq16 x y) // cond: // result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y))) @@ -1741,26 +1683,30 @@ func rewriteValueS390X_OpEq16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDEQ) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpEq32(v *Value, config *Config) bool { +func rewriteValueS390X_OpEq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq32 x y) // cond: // result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW x y)) @@ -1768,10 +1714,10 @@ func rewriteValueS390X_OpEq32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDEQ) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags) @@ -1781,9 +1727,13 @@ func rewriteValueS390X_OpEq32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpEq32F(v *Value, config *Config) bool { +func rewriteValueS390X_OpEq32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq32F x y) // cond: // result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y)) @@ -1791,10 +1741,10 @@ func rewriteValueS390X_OpEq32F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDEQ) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags) @@ -1804,9 +1754,13 @@ func rewriteValueS390X_OpEq32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpEq64(v *Value, config *Config) bool { +func rewriteValueS390X_OpEq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq64 x y) // cond: // result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y)) @@ -1814,10 +1768,10 @@ func rewriteValueS390X_OpEq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDEQ) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) @@ -1827,9 +1781,13 @@ func rewriteValueS390X_OpEq64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpEq64F(v *Value, config *Config) bool { +func rewriteValueS390X_OpEq64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq64F x y) // cond: // result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMP x y)) @@ -1837,10 +1795,10 @@ func rewriteValueS390X_OpEq64F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDEQ) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags) @@ -1850,9 +1808,13 @@ func rewriteValueS390X_OpEq64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpEq8(v *Value, config *Config) bool { +func rewriteValueS390X_OpEq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq8 x y) // cond: // result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y))) @@ -1860,26 +1822,30 @@ func rewriteValueS390X_OpEq8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDEQ) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpEqB(v *Value, config *Config) bool { +func rewriteValueS390X_OpEqB(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqB x y) // cond: // result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y))) @@ -1887,26 +1853,30 @@ func rewriteValueS390X_OpEqB(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDEQ) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpEqPtr(v *Value, config *Config) bool { +func rewriteValueS390X_OpEqPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqPtr x y) // cond: // result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y)) @@ -1914,10 +1884,10 @@ func rewriteValueS390X_OpEqPtr(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDEQ) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) @@ -1927,9 +1897,13 @@ func rewriteValueS390X_OpEqPtr(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGeq16(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16 x y) // cond: // result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y))) @@ -1937,26 +1911,30 @@ func rewriteValueS390X_OpGeq16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpGeq16U(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq16U x y) // cond: // result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y))) @@ -1964,26 +1942,30 @@ func rewriteValueS390X_OpGeq16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpGeq32(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq32 x y) // cond: // result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y)) @@ -1991,10 +1973,10 @@ func rewriteValueS390X_OpGeq32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags) @@ -2004,9 +1986,13 @@ func rewriteValueS390X_OpGeq32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGeq32F(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq32F x y) // cond: // result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y)) @@ -2014,10 +2000,10 @@ func rewriteValueS390X_OpGeq32F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGEnoinv) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags) @@ -2027,9 +2013,13 @@ func rewriteValueS390X_OpGeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGeq32U(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq32U x y) // cond: // result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y)) @@ -2037,10 +2027,10 @@ func rewriteValueS390X_OpGeq32U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPWU, TypeFlags) @@ -2050,9 +2040,13 @@ func rewriteValueS390X_OpGeq32U(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGeq64(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq64 x y) // cond: // result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP x y)) @@ -2060,10 +2054,10 @@ func rewriteValueS390X_OpGeq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) @@ -2073,9 +2067,13 @@ func rewriteValueS390X_OpGeq64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGeq64F(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq64F x y) // cond: // result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y)) @@ -2083,10 +2081,10 @@ func rewriteValueS390X_OpGeq64F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGEnoinv) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags) @@ -2096,9 +2094,13 @@ func rewriteValueS390X_OpGeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGeq64U(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq64U x y) // cond: // result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y)) @@ -2106,10 +2108,10 @@ func rewriteValueS390X_OpGeq64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) @@ -2119,9 +2121,13 @@ func rewriteValueS390X_OpGeq64U(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGeq8(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8 x y) // cond: // result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y))) @@ -2129,26 +2135,30 @@ func rewriteValueS390X_OpGeq8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpGeq8U(v *Value, config *Config) bool { +func rewriteValueS390X_OpGeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq8U x y) // cond: // result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y))) @@ -2156,26 +2166,24 @@ func rewriteValueS390X_OpGeq8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpGetClosurePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -2184,9 +2192,7 @@ func rewriteValueS390X_OpGetClosurePtr(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGetG(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpGetG(v *Value) bool { // match: (GetG mem) // cond: // result: (LoweredGetG mem) @@ -2197,9 +2203,13 @@ func rewriteValueS390X_OpGetG(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGreater16(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16 x y) // cond: // result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y))) @@ -2207,26 +2217,30 @@ func rewriteValueS390X_OpGreater16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpGreater16U(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater16U x y) // cond: // result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y))) @@ -2234,26 +2248,30 @@ func rewriteValueS390X_OpGreater16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpGreater32(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater32 x y) // cond: // result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y)) @@ -2261,10 +2279,10 @@ func rewriteValueS390X_OpGreater32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags) @@ -2274,9 +2292,13 @@ func rewriteValueS390X_OpGreater32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGreater32F(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater32F x y) // cond: // result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y)) @@ -2284,10 +2306,10 @@ func rewriteValueS390X_OpGreater32F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGTnoinv) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags) @@ -2297,9 +2319,13 @@ func rewriteValueS390X_OpGreater32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGreater32U(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater32U x y) // cond: // result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y)) @@ -2307,10 +2333,10 @@ func rewriteValueS390X_OpGreater32U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPWU, TypeFlags) @@ -2320,9 +2346,13 @@ func rewriteValueS390X_OpGreater32U(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGreater64(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater64 x y) // cond: // result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP x y)) @@ -2330,10 +2360,10 @@ func rewriteValueS390X_OpGreater64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) @@ -2343,9 +2373,13 @@ func rewriteValueS390X_OpGreater64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGreater64F(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater64F x y) // cond: // result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y)) @@ -2353,10 +2387,10 @@ func rewriteValueS390X_OpGreater64F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGTnoinv) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags) @@ -2366,9 +2400,13 @@ func rewriteValueS390X_OpGreater64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGreater64U(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater64U x y) // cond: // result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y)) @@ -2376,10 +2414,10 @@ func rewriteValueS390X_OpGreater64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) @@ -2389,9 +2427,13 @@ func rewriteValueS390X_OpGreater64U(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpGreater8(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8 x y) // cond: // result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y))) @@ -2399,26 +2441,30 @@ func rewriteValueS390X_OpGreater8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpGreater8U(v *Value, config *Config) bool { +func rewriteValueS390X_OpGreater8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater8U x y) // cond: // result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y))) @@ -2426,26 +2472,30 @@ func rewriteValueS390X_OpGreater8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpHmul32(v *Value, config *Config) bool { +func rewriteValueS390X_OpHmul32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul32 x y) // cond: // result: (SRDconst [32] (MULLD (MOVWreg x) (MOVWreg y))) @@ -2454,20 +2504,24 @@ func rewriteValueS390X_OpHmul32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRDconst) v.AuxInt = 32 - v0 := b.NewValue0(v.Pos, OpS390XMULLD, config.fe.TypeInt64()) - v1 := b.NewValue0(v.Pos, OpS390XMOVWreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMULLD, fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVWreg, fe.TypeInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpS390XMOVWreg, config.fe.TypeInt64()) + v2 := b.NewValue0(v.Pos, OpS390XMOVWreg, fe.TypeInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueS390X_OpHmul32u(v *Value, config *Config) bool { +func rewriteValueS390X_OpHmul32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Hmul32u x y) // cond: // result: (SRDconst [32] (MULLD (MOVWZreg x) (MOVWZreg y))) @@ -2476,20 +2530,18 @@ func rewriteValueS390X_OpHmul32u(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRDconst) v.AuxInt = 32 - v0 := b.NewValue0(v.Pos, OpS390XMULLD, config.fe.TypeInt64()) - v1 := b.NewValue0(v.Pos, OpS390XMOVWZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMULLD, fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) return true } } -func rewriteValueS390X_OpHmul64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpHmul64(v *Value) bool { // match: (Hmul64 x y) // cond: // result: (MULHD x y) @@ -2502,9 +2554,7 @@ func rewriteValueS390X_OpHmul64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpHmul64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpHmul64u(v *Value) bool { // match: (Hmul64u x y) // cond: // result: (MULHDU x y) @@ -2517,9 +2567,7 @@ func rewriteValueS390X_OpHmul64u(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpITab(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpITab(v *Value) bool { // match: (ITab (Load ptr mem)) // cond: // result: (MOVDload ptr mem) @@ -2537,9 +2585,7 @@ func rewriteValueS390X_OpITab(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpInterCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpInterCall(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -2554,9 +2600,13 @@ func rewriteValueS390X_OpInterCall(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpIsInBounds(v *Value, config *Config) bool { +func rewriteValueS390X_OpIsInBounds(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (IsInBounds idx len) // cond: // result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len)) @@ -2564,10 +2614,10 @@ func rewriteValueS390X_OpIsInBounds(v *Value, config *Config) bool { idx := v.Args[0] len := v.Args[1] v.reset(OpS390XMOVDLT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) @@ -2577,19 +2627,23 @@ func rewriteValueS390X_OpIsInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpIsNonNil(v *Value, config *Config) bool { +func rewriteValueS390X_OpIsNonNil(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (IsNonNil p) // cond: // result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPconst p [0])) for { p := v.Args[0] v.reset(OpS390XMOVDNE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPconst, TypeFlags) @@ -2599,9 +2653,13 @@ func rewriteValueS390X_OpIsNonNil(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpIsSliceInBounds(v *Value, config *Config) bool { +func rewriteValueS390X_OpIsSliceInBounds(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (IsSliceInBounds idx len) // cond: // result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len)) @@ -2609,10 +2667,10 @@ func rewriteValueS390X_OpIsSliceInBounds(v *Value, config *Config) bool { idx := v.Args[0] len := v.Args[1] v.reset(OpS390XMOVDLE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) @@ -2622,9 +2680,13 @@ func rewriteValueS390X_OpIsSliceInBounds(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLeq16(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16 x y) // cond: // result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y))) @@ -2632,26 +2694,30 @@ func rewriteValueS390X_OpLeq16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpLeq16U(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq16U x y) // cond: // result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y))) @@ -2659,26 +2725,30 @@ func rewriteValueS390X_OpLeq16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpLeq32(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq32 x y) // cond: // result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y)) @@ -2686,10 +2756,10 @@ func rewriteValueS390X_OpLeq32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags) @@ -2699,9 +2769,13 @@ func rewriteValueS390X_OpLeq32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLeq32F(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq32F x y) // cond: // result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x)) @@ -2709,10 +2783,10 @@ func rewriteValueS390X_OpLeq32F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGEnoinv) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags) @@ -2722,9 +2796,13 @@ func rewriteValueS390X_OpLeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLeq32U(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq32U x y) // cond: // result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y)) @@ -2732,10 +2810,10 @@ func rewriteValueS390X_OpLeq32U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPWU, TypeFlags) @@ -2745,9 +2823,13 @@ func rewriteValueS390X_OpLeq32U(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLeq64(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq64 x y) // cond: // result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP x y)) @@ -2755,10 +2837,10 @@ func rewriteValueS390X_OpLeq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) @@ -2768,9 +2850,13 @@ func rewriteValueS390X_OpLeq64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLeq64F(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq64F x y) // cond: // result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x)) @@ -2778,10 +2864,10 @@ func rewriteValueS390X_OpLeq64F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGEnoinv) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags) @@ -2791,9 +2877,13 @@ func rewriteValueS390X_OpLeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLeq64U(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq64U x y) // cond: // result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y)) @@ -2801,10 +2891,10 @@ func rewriteValueS390X_OpLeq64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) @@ -2814,9 +2904,13 @@ func rewriteValueS390X_OpLeq64U(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLeq8(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8 x y) // cond: // result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y))) @@ -2824,26 +2918,30 @@ func rewriteValueS390X_OpLeq8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpLeq8U(v *Value, config *Config) bool { +func rewriteValueS390X_OpLeq8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq8U x y) // cond: // result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y))) @@ -2851,26 +2949,30 @@ func rewriteValueS390X_OpLeq8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpLess16(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16 x y) // cond: // result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y))) @@ -2878,26 +2980,30 @@ func rewriteValueS390X_OpLess16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpLess16U(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess16U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less16U x y) // cond: // result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y))) @@ -2905,26 +3011,30 @@ func rewriteValueS390X_OpLess16U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpLess32(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less32 x y) // cond: // result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y)) @@ -2932,10 +3042,10 @@ func rewriteValueS390X_OpLess32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags) @@ -2945,9 +3055,13 @@ func rewriteValueS390X_OpLess32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLess32F(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less32F x y) // cond: // result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x)) @@ -2955,10 +3069,10 @@ func rewriteValueS390X_OpLess32F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGTnoinv) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags) @@ -2968,9 +3082,13 @@ func rewriteValueS390X_OpLess32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLess32U(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess32U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less32U x y) // cond: // result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y)) @@ -2978,10 +3096,10 @@ func rewriteValueS390X_OpLess32U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPWU, TypeFlags) @@ -2991,9 +3109,13 @@ func rewriteValueS390X_OpLess32U(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLess64(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less64 x y) // cond: // result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP x y)) @@ -3001,10 +3123,10 @@ func rewriteValueS390X_OpLess64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) @@ -3014,9 +3136,13 @@ func rewriteValueS390X_OpLess64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLess64F(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less64F x y) // cond: // result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x)) @@ -3024,10 +3150,10 @@ func rewriteValueS390X_OpLess64F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDGTnoinv) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags) @@ -3037,9 +3163,13 @@ func rewriteValueS390X_OpLess64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLess64U(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less64U x y) // cond: // result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y)) @@ -3047,10 +3177,10 @@ func rewriteValueS390X_OpLess64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) @@ -3060,9 +3190,13 @@ func rewriteValueS390X_OpLess64U(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLess8(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8 x y) // cond: // result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y))) @@ -3070,26 +3204,30 @@ func rewriteValueS390X_OpLess8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpLess8U(v *Value, config *Config) bool { +func rewriteValueS390X_OpLess8U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less8U x y) // cond: // result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y))) @@ -3097,26 +3235,24 @@ func rewriteValueS390X_OpLess8U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDLT) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpLoad(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpLoad(v *Value) bool { // match: (Load <t> ptr mem) // cond: (is64BitInt(t) || isPtr(t)) // result: (MOVDload ptr mem) @@ -3254,9 +3390,13 @@ func rewriteValueS390X_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpLsh16x16(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x16 <t> x y) // cond: // result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31]))) @@ -3272,7 +3412,7 @@ func rewriteValueS390X_OpLsh16x16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 31 - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3280,7 +3420,7 @@ func rewriteValueS390X_OpLsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh16x32(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh16x32(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 <t> x y) @@ -3304,7 +3444,7 @@ func rewriteValueS390X_OpLsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh16x64(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh16x64(v *Value) bool { b := v.Block _ = b // match: (Lsh16x64 <t> x y) @@ -3328,9 +3468,13 @@ func rewriteValueS390X_OpLsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh16x8(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x8 <t> x y) // cond: // result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31]))) @@ -3346,7 +3490,7 @@ func rewriteValueS390X_OpLsh16x8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 31 - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3354,9 +3498,13 @@ func rewriteValueS390X_OpLsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh32x16(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x16 <t> x y) // cond: // result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31]))) @@ -3372,7 +3520,7 @@ func rewriteValueS390X_OpLsh32x16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 31 - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3380,7 +3528,7 @@ func rewriteValueS390X_OpLsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh32x32(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh32x32(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 <t> x y) @@ -3404,7 +3552,7 @@ func rewriteValueS390X_OpLsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh32x64(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh32x64(v *Value) bool { b := v.Block _ = b // match: (Lsh32x64 <t> x y) @@ -3428,9 +3576,13 @@ func rewriteValueS390X_OpLsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh32x8(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x8 <t> x y) // cond: // result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31]))) @@ -3446,7 +3598,7 @@ func rewriteValueS390X_OpLsh32x8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 31 - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3454,9 +3606,13 @@ func rewriteValueS390X_OpLsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh64x16(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x16 <t> x y) // cond: // result: (AND (SLD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVHZreg y) [63]))) @@ -3472,7 +3628,7 @@ func rewriteValueS390X_OpLsh64x16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 63 - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3480,7 +3636,7 @@ func rewriteValueS390X_OpLsh64x16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh64x32(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh64x32(v *Value) bool { b := v.Block _ = b // match: (Lsh64x32 <t> x y) @@ -3504,7 +3660,7 @@ func rewriteValueS390X_OpLsh64x32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh64x64(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh64x64(v *Value) bool { b := v.Block _ = b // match: (Lsh64x64 <t> x y) @@ -3528,9 +3684,13 @@ func rewriteValueS390X_OpLsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh64x8(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x8 <t> x y) // cond: // result: (AND (SLD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVBZreg y) [63]))) @@ -3546,7 +3706,7 @@ func rewriteValueS390X_OpLsh64x8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 63 - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3554,9 +3714,13 @@ func rewriteValueS390X_OpLsh64x8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh8x16(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x16 <t> x y) // cond: // result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31]))) @@ -3572,7 +3736,7 @@ func rewriteValueS390X_OpLsh8x16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 31 - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3580,7 +3744,7 @@ func rewriteValueS390X_OpLsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh8x32(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh8x32(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 <t> x y) @@ -3604,7 +3768,7 @@ func rewriteValueS390X_OpLsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh8x64(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh8x64(v *Value) bool { b := v.Block _ = b // match: (Lsh8x64 <t> x y) @@ -3628,9 +3792,13 @@ func rewriteValueS390X_OpLsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpLsh8x8(v *Value, config *Config) bool { +func rewriteValueS390X_OpLsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x8 <t> x y) // cond: // result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31]))) @@ -3646,7 +3814,7 @@ func rewriteValueS390X_OpLsh8x8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 31 - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -3654,9 +3822,13 @@ func rewriteValueS390X_OpLsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpMod16(v *Value, config *Config) bool { +func rewriteValueS390X_OpMod16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16 x y) // cond: // result: (MODW (MOVHreg x) (MOVHreg y)) @@ -3664,18 +3836,22 @@ func rewriteValueS390X_OpMod16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMODW) - v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueS390X_OpMod16u(v *Value, config *Config) bool { +func rewriteValueS390X_OpMod16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod16u x y) // cond: // result: (MODWU (MOVHZreg x) (MOVHZreg y)) @@ -3683,18 +3859,22 @@ func rewriteValueS390X_OpMod16u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMODWU) - v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueS390X_OpMod32(v *Value, config *Config) bool { +func rewriteValueS390X_OpMod32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32 x y) // cond: // result: (MODW (MOVWreg x) y) @@ -3702,16 +3882,20 @@ func rewriteValueS390X_OpMod32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMODW) - v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v.AddArg(y) return true } } -func rewriteValueS390X_OpMod32u(v *Value, config *Config) bool { +func rewriteValueS390X_OpMod32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod32u x y) // cond: // result: (MODWU (MOVWZreg x) y) @@ -3719,16 +3903,14 @@ func rewriteValueS390X_OpMod32u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMODWU) - v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) v.AddArg(y) return true } } -func rewriteValueS390X_OpMod64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpMod64(v *Value) bool { // match: (Mod64 x y) // cond: // result: (MODD x y) @@ -3741,9 +3923,7 @@ func rewriteValueS390X_OpMod64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpMod64u(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpMod64u(v *Value) bool { // match: (Mod64u x y) // cond: // result: (MODDU x y) @@ -3756,9 +3936,13 @@ func rewriteValueS390X_OpMod64u(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpMod8(v *Value, config *Config) bool { +func rewriteValueS390X_OpMod8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8 x y) // cond: // result: (MODW (MOVBreg x) (MOVBreg y)) @@ -3766,18 +3950,22 @@ func rewriteValueS390X_OpMod8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMODW) - v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueS390X_OpMod8u(v *Value, config *Config) bool { +func rewriteValueS390X_OpMod8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mod8u x y) // cond: // result: (MODWU (MOVBZreg x) (MOVBZreg y)) @@ -3785,18 +3973,22 @@ func rewriteValueS390X_OpMod8u(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMODWU) - v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValueS390X_OpMove(v *Value, config *Config) bool { +func rewriteValueS390X_OpMove(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Move [0] _ _ mem) // cond: // result: mem @@ -3822,7 +4014,7 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpS390XMOVBstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, fe.TypeUInt8()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -3841,7 +4033,7 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpS390XMOVHstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -3860,7 +4052,7 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpS390XMOVWstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -3879,7 +4071,7 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { mem := v.Args[2] v.reset(OpS390XMOVDstore) v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVDload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64()) v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) @@ -3899,14 +4091,14 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { v.reset(OpS390XMOVDstore) v.AuxInt = 8 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVDload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64()) v0.AuxInt = 8 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpS390XMOVDload, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -3927,7 +4119,7 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { v.reset(OpS390XMOVDstore) v.AuxInt = 16 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVDload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64()) v0.AuxInt = 16 v0.AddArg(src) v0.AddArg(mem) @@ -3935,14 +4127,14 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, TypeMem) v1.AuxInt = 8 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpS390XMOVDload, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64()) v2.AuxInt = 8 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpS390XMOVDstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpS390XMOVDload, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -3964,14 +4156,14 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { v.reset(OpS390XMOVBstore) v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, fe.TypeUInt8()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -3992,14 +4184,14 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { v.reset(OpS390XMOVBstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, fe.TypeUInt8()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -4020,14 +4212,14 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { v.reset(OpS390XMOVHstore) v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) @@ -4048,7 +4240,7 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { v.reset(OpS390XMOVBstore) v.AuxInt = 6 v.AddArg(dst) - v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, fe.TypeUInt8()) v0.AuxInt = 6 v0.AddArg(src) v0.AddArg(mem) @@ -4056,14 +4248,14 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, TypeMem) v1.AuxInt = 4 v1.AddArg(dst) - v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, config.fe.TypeUInt16()) + v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16()) v2.AuxInt = 4 v2.AddArg(src) v2.AddArg(mem) v1.AddArg(v2) v3 := b.NewValue0(v.Pos, OpS390XMOVWstore, TypeMem) v3.AddArg(dst) - v4 := b.NewValue0(v.Pos, OpS390XMOVWZload, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32()) v4.AddArg(src) v4.AddArg(mem) v3.AddArg(v4) @@ -4198,9 +4390,7 @@ func rewriteValueS390X_OpMove(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpMul16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpMul16(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULLW x y) @@ -4213,9 +4403,7 @@ func rewriteValueS390X_OpMul16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpMul32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpMul32(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULLW x y) @@ -4228,9 +4416,7 @@ func rewriteValueS390X_OpMul32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpMul32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpMul32F(v *Value) bool { // match: (Mul32F x y) // cond: // result: (FMULS x y) @@ -4243,9 +4429,7 @@ func rewriteValueS390X_OpMul32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpMul64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpMul64(v *Value) bool { // match: (Mul64 x y) // cond: // result: (MULLD x y) @@ -4258,9 +4442,7 @@ func rewriteValueS390X_OpMul64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpMul64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpMul64F(v *Value) bool { // match: (Mul64F x y) // cond: // result: (FMUL x y) @@ -4273,9 +4455,7 @@ func rewriteValueS390X_OpMul64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpMul8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpMul8(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULLW x y) @@ -4288,24 +4468,26 @@ func rewriteValueS390X_OpMul8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNeg16(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeg16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neg16 x) // cond: // result: (NEGW (MOVHreg x)) for { x := v.Args[0] v.reset(OpS390XNEGW) - v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValueS390X_OpNeg32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpNeg32(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEGW x) @@ -4316,9 +4498,7 @@ func rewriteValueS390X_OpNeg32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNeg32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpNeg32F(v *Value) bool { // match: (Neg32F x) // cond: // result: (FNEGS x) @@ -4329,9 +4509,7 @@ func rewriteValueS390X_OpNeg32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNeg64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpNeg64(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEG x) @@ -4342,9 +4520,7 @@ func rewriteValueS390X_OpNeg64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNeg64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpNeg64F(v *Value) bool { // match: (Neg64F x) // cond: // result: (FNEG x) @@ -4355,24 +4531,32 @@ func rewriteValueS390X_OpNeg64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNeg8(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeg8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neg8 x) // cond: // result: (NEGW (MOVBreg x)) for { x := v.Args[0] v.reset(OpS390XNEGW) - v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValueS390X_OpNeq16(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeq16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq16 x y) // cond: // result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y))) @@ -4380,26 +4564,30 @@ func rewriteValueS390X_OpNeq16(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDNE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpNeq32(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeq32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq32 x y) // cond: // result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y)) @@ -4407,10 +4595,10 @@ func rewriteValueS390X_OpNeq32(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDNE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags) @@ -4420,9 +4608,13 @@ func rewriteValueS390X_OpNeq32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNeq32F(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeq32F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq32F x y) // cond: // result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y)) @@ -4430,10 +4622,10 @@ func rewriteValueS390X_OpNeq32F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDNE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags) @@ -4443,9 +4635,13 @@ func rewriteValueS390X_OpNeq32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNeq64(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq64 x y) // cond: // result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y)) @@ -4453,10 +4649,10 @@ func rewriteValueS390X_OpNeq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDNE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) @@ -4466,9 +4662,13 @@ func rewriteValueS390X_OpNeq64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNeq64F(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeq64F(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq64F x y) // cond: // result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMP x y)) @@ -4476,10 +4676,10 @@ func rewriteValueS390X_OpNeq64F(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDNE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags) @@ -4489,9 +4689,13 @@ func rewriteValueS390X_OpNeq64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNeq8(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeq8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq8 x y) // cond: // result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y))) @@ -4499,26 +4703,30 @@ func rewriteValueS390X_OpNeq8(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDNE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpNeqB(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeqB(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (NeqB x y) // cond: // result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y))) @@ -4526,26 +4734,30 @@ func rewriteValueS390X_OpNeqB(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDNE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) - v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v4.AddArg(y) v2.AddArg(v4) v.AddArg(v2) return true } } -func rewriteValueS390X_OpNeqPtr(v *Value, config *Config) bool { +func rewriteValueS390X_OpNeqPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (NeqPtr x y) // cond: // result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y)) @@ -4553,10 +4765,10 @@ func rewriteValueS390X_OpNeqPtr(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpS390XMOVDNE) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = 0 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v1.AuxInt = 1 v.AddArg(v1) v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags) @@ -4566,9 +4778,7 @@ func rewriteValueS390X_OpNeqPtr(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNilCheck(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpNilCheck(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -4581,9 +4791,7 @@ func rewriteValueS390X_OpNilCheck(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpNot(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpNot(v *Value) bool { // match: (Not x) // cond: // result: (XORWconst [1] x) @@ -4595,9 +4803,13 @@ func rewriteValueS390X_OpNot(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpOffPtr(v *Value, config *Config) bool { +func rewriteValueS390X_OpOffPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (OffPtr [off] ptr:(SP)) // cond: // result: (MOVDaddr [off] ptr) @@ -4633,16 +4845,14 @@ func rewriteValueS390X_OpOffPtr(v *Value, config *Config) bool { off := v.AuxInt ptr := v.Args[0] v.reset(OpS390XADD) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = off v.AddArg(v0) v.AddArg(ptr) return true } } -func rewriteValueS390X_OpOr16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpOr16(v *Value) bool { // match: (Or16 x y) // cond: // result: (ORW x y) @@ -4655,9 +4865,7 @@ func rewriteValueS390X_OpOr16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpOr32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpOr32(v *Value) bool { // match: (Or32 x y) // cond: // result: (ORW x y) @@ -4670,9 +4878,7 @@ func rewriteValueS390X_OpOr32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpOr64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpOr64(v *Value) bool { // match: (Or64 x y) // cond: // result: (OR x y) @@ -4685,9 +4891,7 @@ func rewriteValueS390X_OpOr64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpOr8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpOr8(v *Value) bool { // match: (Or8 x y) // cond: // result: (ORW x y) @@ -4700,9 +4904,7 @@ func rewriteValueS390X_OpOr8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpOrB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpOrB(v *Value) bool { // match: (OrB x y) // cond: // result: (ORW x y) @@ -4715,9 +4917,7 @@ func rewriteValueS390X_OpOrB(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpRound32F(v *Value) bool { // match: (Round32F x) // cond: // result: (LoweredRound32F x) @@ -4728,9 +4928,7 @@ func rewriteValueS390X_OpRound32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpRound64F(v *Value) bool { // match: (Round64F x) // cond: // result: (LoweredRound64F x) @@ -4741,9 +4939,13 @@ func rewriteValueS390X_OpRound64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh16Ux16(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh16Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux16 <t> x y) // cond: // result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [15]))) @@ -4753,7 +4955,7 @@ func rewriteValueS390X_OpRsh16Ux16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XANDW) v0 := b.NewValue0(v.Pos, OpS390XSRW, t) - v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -4761,7 +4963,7 @@ func rewriteValueS390X_OpRsh16Ux16(v *Value, config *Config) bool { v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v3.AuxInt = 15 - v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -4769,9 +4971,13 @@ func rewriteValueS390X_OpRsh16Ux16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh16Ux32(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh16Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux32 <t> x y) // cond: // result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPWUconst y [15]))) @@ -4781,7 +4987,7 @@ func rewriteValueS390X_OpRsh16Ux32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XANDW) v0 := b.NewValue0(v.Pos, OpS390XSRW, t) - v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -4795,9 +5001,13 @@ func rewriteValueS390X_OpRsh16Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh16Ux64(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh16Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux64 <t> x y) // cond: // result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPUconst y [15]))) @@ -4807,7 +5017,7 @@ func rewriteValueS390X_OpRsh16Ux64(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XANDW) v0 := b.NewValue0(v.Pos, OpS390XSRW, t) - v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -4821,9 +5031,13 @@ func rewriteValueS390X_OpRsh16Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh16Ux8(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh16Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux8 <t> x y) // cond: // result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [15]))) @@ -4833,7 +5047,7 @@ func rewriteValueS390X_OpRsh16Ux8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XANDW) v0 := b.NewValue0(v.Pos, OpS390XSRW, t) - v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -4841,7 +5055,7 @@ func rewriteValueS390X_OpRsh16Ux8(v *Value, config *Config) bool { v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v3.AuxInt = 15 - v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -4849,9 +5063,13 @@ func rewriteValueS390X_OpRsh16Ux8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh16x16(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh16x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x16 <t> x y) // cond: // result: (SRAW <t> (MOVHreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [15]))))) @@ -4861,7 +5079,7 @@ func rewriteValueS390X_OpRsh16x16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRAW) v.Type = t - v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type) @@ -4870,7 +5088,7 @@ func rewriteValueS390X_OpRsh16x16(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type) v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v4.AuxInt = 15 - v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v3.AddArg(v4) @@ -4880,9 +5098,13 @@ func rewriteValueS390X_OpRsh16x16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh16x32(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh16x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x32 <t> x y) // cond: // result: (SRAW <t> (MOVHreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst y [15]))))) @@ -4892,7 +5114,7 @@ func rewriteValueS390X_OpRsh16x32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRAW) v.Type = t - v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type) @@ -4909,9 +5131,13 @@ func rewriteValueS390X_OpRsh16x32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh16x64(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x64 <t> x y) // cond: // result: (SRAW <t> (MOVHreg x) (OR <y.Type> y (NOT <y.Type> (SUBEcarrymask <y.Type> (CMPUconst y [15]))))) @@ -4921,7 +5147,7 @@ func rewriteValueS390X_OpRsh16x64(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRAW) v.Type = t - v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XOR, y.Type) @@ -4938,9 +5164,13 @@ func rewriteValueS390X_OpRsh16x64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh16x8(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh16x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x8 <t> x y) // cond: // result: (SRAW <t> (MOVHreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [15]))))) @@ -4950,7 +5180,7 @@ func rewriteValueS390X_OpRsh16x8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRAW) v.Type = t - v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type) @@ -4959,7 +5189,7 @@ func rewriteValueS390X_OpRsh16x8(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type) v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v4.AuxInt = 15 - v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v3.AddArg(v4) @@ -4969,9 +5199,13 @@ func rewriteValueS390X_OpRsh16x8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh32Ux16(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh32Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux16 <t> x y) // cond: // result: (ANDW (SRW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31]))) @@ -4987,7 +5221,7 @@ func rewriteValueS390X_OpRsh32Ux16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 31 - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -4995,7 +5229,7 @@ func rewriteValueS390X_OpRsh32Ux16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh32Ux32(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh32Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 <t> x y) @@ -5019,7 +5253,7 @@ func rewriteValueS390X_OpRsh32Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh32Ux64(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh32Ux64(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux64 <t> x y) @@ -5043,9 +5277,13 @@ func rewriteValueS390X_OpRsh32Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh32Ux8(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh32Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux8 <t> x y) // cond: // result: (ANDW (SRW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31]))) @@ -5061,7 +5299,7 @@ func rewriteValueS390X_OpRsh32Ux8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 31 - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -5069,9 +5307,13 @@ func rewriteValueS390X_OpRsh32Ux8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh32x16(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh32x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x16 <t> x y) // cond: // result: (SRAW <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [31]))))) @@ -5088,7 +5330,7 @@ func rewriteValueS390X_OpRsh32x16(v *Value, config *Config) bool { v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type) v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v3.AuxInt = 31 - v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -5098,7 +5340,7 @@ func rewriteValueS390X_OpRsh32x16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh32x32(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh32x32(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 <t> x y) @@ -5125,7 +5367,7 @@ func rewriteValueS390X_OpRsh32x32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh32x64(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh32x64(v *Value) bool { b := v.Block _ = b // match: (Rsh32x64 <t> x y) @@ -5152,9 +5394,13 @@ func rewriteValueS390X_OpRsh32x64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh32x8(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh32x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x8 <t> x y) // cond: // result: (SRAW <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [31]))))) @@ -5171,7 +5417,7 @@ func rewriteValueS390X_OpRsh32x8(v *Value, config *Config) bool { v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type) v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v3.AuxInt = 31 - v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -5181,9 +5427,13 @@ func rewriteValueS390X_OpRsh32x8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh64Ux16(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh64Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux16 <t> x y) // cond: // result: (AND (SRD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVHZreg y) [63]))) @@ -5199,7 +5449,7 @@ func rewriteValueS390X_OpRsh64Ux16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 63 - v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -5207,7 +5457,7 @@ func rewriteValueS390X_OpRsh64Ux16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh64Ux32(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh64Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux32 <t> x y) @@ -5231,7 +5481,7 @@ func rewriteValueS390X_OpRsh64Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh64Ux64(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh64Ux64(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux64 <t> x y) @@ -5255,9 +5505,13 @@ func rewriteValueS390X_OpRsh64Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh64Ux8(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh64Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux8 <t> x y) // cond: // result: (AND (SRD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVBZreg y) [63]))) @@ -5273,7 +5527,7 @@ func rewriteValueS390X_OpRsh64Ux8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t) v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v2.AuxInt = 63 - v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v3.AddArg(y) v2.AddArg(v3) v1.AddArg(v2) @@ -5281,9 +5535,13 @@ func rewriteValueS390X_OpRsh64Ux8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh64x16(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x16 <t> x y) // cond: // result: (SRAD <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [63]))))) @@ -5300,7 +5558,7 @@ func rewriteValueS390X_OpRsh64x16(v *Value, config *Config) bool { v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type) v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v3.AuxInt = 63 - v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -5310,7 +5568,7 @@ func rewriteValueS390X_OpRsh64x16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh64x32(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh64x32(v *Value) bool { b := v.Block _ = b // match: (Rsh64x32 <t> x y) @@ -5337,7 +5595,7 @@ func rewriteValueS390X_OpRsh64x32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh64x64(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh64x64(v *Value) bool { b := v.Block _ = b // match: (Rsh64x64 <t> x y) @@ -5364,9 +5622,13 @@ func rewriteValueS390X_OpRsh64x64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh64x8(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x8 <t> x y) // cond: // result: (SRAD <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [63]))))) @@ -5383,7 +5645,7 @@ func rewriteValueS390X_OpRsh64x8(v *Value, config *Config) bool { v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type) v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v3.AuxInt = 63 - v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -5393,9 +5655,13 @@ func rewriteValueS390X_OpRsh64x8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh8Ux16(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh8Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux16 <t> x y) // cond: // result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [7]))) @@ -5405,7 +5671,7 @@ func rewriteValueS390X_OpRsh8Ux16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XANDW) v0 := b.NewValue0(v.Pos, OpS390XSRW, t) - v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -5413,7 +5679,7 @@ func rewriteValueS390X_OpRsh8Ux16(v *Value, config *Config) bool { v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v3.AuxInt = 7 - v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -5421,9 +5687,13 @@ func rewriteValueS390X_OpRsh8Ux16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh8Ux32(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh8Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux32 <t> x y) // cond: // result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPWUconst y [7]))) @@ -5433,7 +5703,7 @@ func rewriteValueS390X_OpRsh8Ux32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XANDW) v0 := b.NewValue0(v.Pos, OpS390XSRW, t) - v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -5447,9 +5717,13 @@ func rewriteValueS390X_OpRsh8Ux32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh8Ux64(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh8Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux64 <t> x y) // cond: // result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPUconst y [7]))) @@ -5459,7 +5733,7 @@ func rewriteValueS390X_OpRsh8Ux64(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XANDW) v0 := b.NewValue0(v.Pos, OpS390XSRW, t) - v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -5473,9 +5747,13 @@ func rewriteValueS390X_OpRsh8Ux64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh8Ux8(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh8Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux8 <t> x y) // cond: // result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [7]))) @@ -5485,7 +5763,7 @@ func rewriteValueS390X_OpRsh8Ux8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XANDW) v0 := b.NewValue0(v.Pos, OpS390XSRW, t) - v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v1.AddArg(x) v0.AddArg(v1) v0.AddArg(y) @@ -5493,7 +5771,7 @@ func rewriteValueS390X_OpRsh8Ux8(v *Value, config *Config) bool { v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t) v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v3.AuxInt = 7 - v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v4.AddArg(y) v3.AddArg(v4) v2.AddArg(v3) @@ -5501,9 +5779,13 @@ func rewriteValueS390X_OpRsh8Ux8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh8x16(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh8x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x16 <t> x y) // cond: // result: (SRAW <t> (MOVBreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [7]))))) @@ -5513,7 +5795,7 @@ func rewriteValueS390X_OpRsh8x16(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRAW) v.Type = t - v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type) @@ -5522,7 +5804,7 @@ func rewriteValueS390X_OpRsh8x16(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type) v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v4.AuxInt = 7 - v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v3.AddArg(v4) @@ -5532,9 +5814,13 @@ func rewriteValueS390X_OpRsh8x16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh8x32(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh8x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x32 <t> x y) // cond: // result: (SRAW <t> (MOVBreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst y [7]))))) @@ -5544,7 +5830,7 @@ func rewriteValueS390X_OpRsh8x32(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRAW) v.Type = t - v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type) @@ -5561,9 +5847,13 @@ func rewriteValueS390X_OpRsh8x32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh8x64(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x64 <t> x y) // cond: // result: (SRAW <t> (MOVBreg x) (OR <y.Type> y (NOT <y.Type> (SUBEcarrymask <y.Type> (CMPUconst y [7]))))) @@ -5573,7 +5863,7 @@ func rewriteValueS390X_OpRsh8x64(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRAW) v.Type = t - v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XOR, y.Type) @@ -5590,9 +5880,13 @@ func rewriteValueS390X_OpRsh8x64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpRsh8x8(v *Value, config *Config) bool { +func rewriteValueS390X_OpRsh8x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x8 <t> x y) // cond: // result: (SRAW <t> (MOVBreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [7]))))) @@ -5602,7 +5896,7 @@ func rewriteValueS390X_OpRsh8x8(v *Value, config *Config) bool { y := v.Args[1] v.reset(OpS390XSRAW) v.Type = t - v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, config.fe.TypeInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64()) v0.AddArg(x) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type) @@ -5611,7 +5905,7 @@ func rewriteValueS390X_OpRsh8x8(v *Value, config *Config) bool { v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type) v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags) v4.AuxInt = 7 - v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64()) v5.AddArg(y) v4.AddArg(v5) v3.AddArg(v4) @@ -5621,9 +5915,7 @@ func rewriteValueS390X_OpRsh8x8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpS390XADD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XADD(v *Value) bool { // match: (ADD x (MOVDconst [c])) // cond: is32Bit(c) // result: (ADDconst [c] x) @@ -5823,9 +6115,7 @@ func rewriteValueS390X_OpS390XADD(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XADDW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XADDW(v *Value) bool { // match: (ADDW x (MOVDconst [c])) // cond: // result: (ADDWconst [c] x) @@ -6027,9 +6317,7 @@ func rewriteValueS390X_OpS390XADDW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XADDWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XADDWconst(v *Value) bool { // match: (ADDWconst [c] x) // cond: int32(c)==0 // result: x @@ -6076,9 +6364,7 @@ func rewriteValueS390X_OpS390XADDWconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XADDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XADDconst(v *Value) bool { // match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB))) // cond: ((c+d)&1 == 0) && is32Bit(c+d) // result: (MOVDaddr [c+d] {s} x) @@ -6195,9 +6481,7 @@ func rewriteValueS390X_OpS390XADDconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XAND(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XAND(v *Value) bool { // match: (AND x (MOVDconst [c])) // cond: is32Bit(c) && c < 0 // result: (ANDconst [c] x) @@ -6415,9 +6699,7 @@ func rewriteValueS390X_OpS390XAND(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XANDW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XANDW(v *Value) bool { // match: (ANDW x (MOVDconst [c])) // cond: // result: (ANDWconst [c] x) @@ -6567,9 +6849,7 @@ func rewriteValueS390X_OpS390XANDW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XANDWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XANDWconst(v *Value) bool { // match: (ANDWconst [c] (ANDWconst [d] x)) // cond: // result: (ANDWconst [c & d] x) @@ -6652,9 +6932,7 @@ func rewriteValueS390X_OpS390XANDWconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XANDconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XANDconst(v *Value) bool { // match: (ANDconst [c] (ANDconst [d] x)) // cond: // result: (ANDconst [c & d] x) @@ -6711,7 +6989,7 @@ func rewriteValueS390X_OpS390XANDconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XCMP(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XCMP(v *Value) bool { b := v.Block _ = b // match: (CMP x (MOVDconst [c])) @@ -6754,7 +7032,7 @@ func rewriteValueS390X_OpS390XCMP(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XCMPU(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XCMPU(v *Value) bool { b := v.Block _ = b // match: (CMPU x (MOVDconst [c])) @@ -6797,9 +7075,7 @@ func rewriteValueS390X_OpS390XCMPU(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XCMPUconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XCMPUconst(v *Value) bool { // match: (CMPUconst (MOVDconst [x]) [y]) // cond: uint64(x)==uint64(y) // result: (FlagEQ) @@ -6850,7 +7126,7 @@ func rewriteValueS390X_OpS390XCMPUconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XCMPW(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XCMPW(v *Value) bool { b := v.Block _ = b // match: (CMPW x (MOVDconst [c])) @@ -6887,7 +7163,7 @@ func rewriteValueS390X_OpS390XCMPW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XCMPWU(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XCMPWU(v *Value) bool { b := v.Block _ = b // match: (CMPWU x (MOVDconst [c])) @@ -6924,9 +7200,7 @@ func rewriteValueS390X_OpS390XCMPWU(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XCMPWUconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XCMPWUconst(v *Value) bool { // match: (CMPWUconst (MOVDconst [x]) [y]) // cond: uint32(x)==uint32(y) // result: (FlagEQ) @@ -6977,9 +7251,7 @@ func rewriteValueS390X_OpS390XCMPWUconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XCMPWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool { // match: (CMPWconst (MOVDconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -7062,9 +7334,7 @@ func rewriteValueS390X_OpS390XCMPWconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XCMPconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XCMPconst(v *Value) bool { // match: (CMPconst (MOVDconst [x]) [y]) // cond: x==y // result: (FlagEQ) @@ -7192,9 +7462,7 @@ func rewriteValueS390X_OpS390XCMPconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFADD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFADD(v *Value) bool { // match: (FADD x (FMUL y z)) // cond: // result: (FMADD x y z) @@ -7231,9 +7499,7 @@ func rewriteValueS390X_OpS390XFADD(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFADDS(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFADDS(v *Value) bool { // match: (FADDS x (FMULS y z)) // cond: // result: (FMADDS x y z) @@ -7270,9 +7536,7 @@ func rewriteValueS390X_OpS390XFADDS(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFMOVDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFMOVDload(v *Value) bool { // match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (FMOVDload [off1+off2] {sym} ptr mem) @@ -7372,9 +7636,7 @@ func rewriteValueS390X_OpS390XFMOVDload(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFMOVDloadidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFMOVDloadidx(v *Value) bool { // match: (FMOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (FMOVDloadidx [c+d] {sym} ptr idx mem) @@ -7421,9 +7683,7 @@ func rewriteValueS390X_OpS390XFMOVDloadidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFMOVDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFMOVDstore(v *Value) bool { // match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is20Bit(off1+off2) // result: (FMOVDstore [off1+off2] {sym} ptr val mem) @@ -7531,9 +7791,7 @@ func rewriteValueS390X_OpS390XFMOVDstore(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFMOVDstoreidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFMOVDstoreidx(v *Value) bool { // match: (FMOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem) @@ -7584,9 +7842,7 @@ func rewriteValueS390X_OpS390XFMOVDstoreidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFMOVSload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFMOVSload(v *Value) bool { // match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (FMOVSload [off1+off2] {sym} ptr mem) @@ -7686,9 +7942,7 @@ func rewriteValueS390X_OpS390XFMOVSload(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFMOVSloadidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFMOVSloadidx(v *Value) bool { // match: (FMOVSloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (FMOVSloadidx [c+d] {sym} ptr idx mem) @@ -7735,9 +7989,7 @@ func rewriteValueS390X_OpS390XFMOVSloadidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFMOVSstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFMOVSstore(v *Value) bool { // match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is20Bit(off1+off2) // result: (FMOVSstore [off1+off2] {sym} ptr val mem) @@ -7845,9 +8097,7 @@ func rewriteValueS390X_OpS390XFMOVSstore(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFMOVSstoreidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFMOVSstoreidx(v *Value) bool { // match: (FMOVSstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem) @@ -7898,9 +8148,7 @@ func rewriteValueS390X_OpS390XFMOVSstoreidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFSUB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFSUB(v *Value) bool { // match: (FSUB (FMUL y z) x) // cond: // result: (FMSUB x y z) @@ -7920,9 +8168,7 @@ func rewriteValueS390X_OpS390XFSUB(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XFSUBS(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XFSUBS(v *Value) bool { // match: (FSUBS (FMULS y z) x) // cond: // result: (FMSUBS x y z) @@ -7942,9 +8188,7 @@ func rewriteValueS390X_OpS390XFSUBS(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XLoweredRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XLoweredRound32F(v *Value) bool { // match: (LoweredRound32F x:(FMOVSconst)) // cond: // result: x @@ -7960,9 +8204,7 @@ func rewriteValueS390X_OpS390XLoweredRound32F(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XLoweredRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XLoweredRound64F(v *Value) bool { // match: (LoweredRound64F x:(FMOVDconst)) // cond: // result: x @@ -7978,9 +8220,7 @@ func rewriteValueS390X_OpS390XLoweredRound64F(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVBZload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVBZload(v *Value) bool { // match: (MOVBZload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: (MOVBZreg x) @@ -8102,9 +8342,7 @@ func rewriteValueS390X_OpS390XMOVBZload(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVBZloadidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVBZloadidx(v *Value) bool { // match: (MOVBZloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (MOVBZloadidx [c+d] {sym} ptr idx mem) @@ -8151,7 +8389,7 @@ func rewriteValueS390X_OpS390XMOVBZloadidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVBZreg(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMOVBZreg(v *Value) bool { b := v.Block _ = b // match: (MOVBZreg x:(MOVDLT (MOVDconst [c]) (MOVDconst [d]) _)) @@ -8461,9 +8699,7 @@ func rewriteValueS390X_OpS390XMOVBZreg(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVBload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVBload(v *Value) bool { // match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -8513,7 +8749,7 @@ func rewriteValueS390X_OpS390XMOVBload(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVBreg(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMOVBreg(v *Value) bool { b := v.Block _ = b // match: (MOVBreg x:(MOVBload _ _)) @@ -8596,9 +8832,7 @@ func rewriteValueS390X_OpS390XMOVBreg(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVBstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool { // match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem) // cond: // result: (MOVBstore [off] {sym} ptr x mem) @@ -9135,9 +9369,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool { // match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -9216,9 +9448,7 @@ func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool { // match: (MOVBstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (MOVBstoreidx [c+d] {sym} ptr idx val mem) @@ -9673,9 +9903,7 @@ func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDEQ(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDEQ(v *Value) bool { // match: (MOVDEQ x y (InvertFlags cmp)) // cond: // result: (MOVDEQ x y cmp) @@ -9737,9 +9965,7 @@ func rewriteValueS390X_OpS390XMOVDEQ(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDGE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDGE(v *Value) bool { // match: (MOVDGE x y (InvertFlags cmp)) // cond: // result: (MOVDLE x y cmp) @@ -9801,9 +10027,7 @@ func rewriteValueS390X_OpS390XMOVDGE(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDGT(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDGT(v *Value) bool { // match: (MOVDGT x y (InvertFlags cmp)) // cond: // result: (MOVDLT x y cmp) @@ -9865,9 +10089,7 @@ func rewriteValueS390X_OpS390XMOVDGT(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDLE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDLE(v *Value) bool { // match: (MOVDLE x y (InvertFlags cmp)) // cond: // result: (MOVDGE x y cmp) @@ -9929,9 +10151,7 @@ func rewriteValueS390X_OpS390XMOVDLE(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDLT(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDLT(v *Value) bool { // match: (MOVDLT x y (InvertFlags cmp)) // cond: // result: (MOVDGT x y cmp) @@ -9993,9 +10213,7 @@ func rewriteValueS390X_OpS390XMOVDLT(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDNE(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDNE(v *Value) bool { // match: (MOVDNE x y (InvertFlags cmp)) // cond: // result: (MOVDNE x y cmp) @@ -10057,9 +10275,7 @@ func rewriteValueS390X_OpS390XMOVDNE(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDaddridx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDaddridx(v *Value) bool { // match: (MOVDaddridx [c] {s} (ADDconst [d] x) y) // cond: is20Bit(c+d) && x.Op != OpSB // result: (MOVDaddridx [c+d] {s} x y) @@ -10156,9 +10372,7 @@ func rewriteValueS390X_OpS390XMOVDaddridx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDload(v *Value) bool { // match: (MOVDload [off] {sym} ptr (MOVDstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: (MOVDreg x) @@ -10280,9 +10494,7 @@ func rewriteValueS390X_OpS390XMOVDload(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDloadidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDloadidx(v *Value) bool { // match: (MOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (MOVDloadidx [c+d] {sym} ptr idx mem) @@ -10329,7 +10541,7 @@ func rewriteValueS390X_OpS390XMOVDloadidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDnop(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMOVDnop(v *Value) bool { b := v.Block _ = b // match: (MOVDnop <t> x) @@ -10655,7 +10867,7 @@ func rewriteValueS390X_OpS390XMOVDnop(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDreg(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMOVDreg(v *Value) bool { b := v.Block _ = b // match: (MOVDreg <t> x) @@ -10993,9 +11205,7 @@ func rewriteValueS390X_OpS390XMOVDreg(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is20Bit(off1+off2) // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -11237,9 +11447,7 @@ func rewriteValueS390X_OpS390XMOVDstore(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool { // match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVDstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -11289,9 +11497,7 @@ func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value) bool { // match: (MOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (MOVDstoreidx [c+d] {sym} ptr idx val mem) @@ -11342,9 +11548,7 @@ func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHBRstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool { // match: (MOVHBRstore [i] {s} p (SRDconst [16] w) x:(MOVHBRstore [i-2] {s} p w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVWBRstore [i-2] {s} p w mem) @@ -11529,9 +11733,7 @@ func rewriteValueS390X_OpS390XMOVHBRstore(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value) bool { // match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVWBRstoreidx [i-2] {s} p idx w mem) @@ -11736,9 +11938,7 @@ func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHZload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVHZload(v *Value) bool { // match: (MOVHZload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: (MOVHZreg x) @@ -11860,9 +12060,7 @@ func rewriteValueS390X_OpS390XMOVHZload(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHZloadidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVHZloadidx(v *Value) bool { // match: (MOVHZloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (MOVHZloadidx [c+d] {sym} ptr idx mem) @@ -11909,7 +12107,7 @@ func rewriteValueS390X_OpS390XMOVHZloadidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHZreg(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMOVHZreg(v *Value) bool { b := v.Block _ = b // match: (MOVHZreg x:(MOVBZload _ _)) @@ -12043,9 +12241,7 @@ func rewriteValueS390X_OpS390XMOVHZreg(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVHload(v *Value) bool { // match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -12095,7 +12291,7 @@ func rewriteValueS390X_OpS390XMOVHload(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHreg(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMOVHreg(v *Value) bool { b := v.Block _ = b // match: (MOVHreg x:(MOVBload _ _)) @@ -12226,9 +12422,7 @@ func rewriteValueS390X_OpS390XMOVHreg(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool { // match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem) // cond: // result: (MOVHstore [off] {sym} ptr x mem) @@ -12583,9 +12777,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool { // match: (MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVHstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -12664,9 +12856,7 @@ func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value) bool { // match: (MOVHstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (MOVHstoreidx [c+d] {sym} ptr idx val mem) @@ -12919,9 +13109,7 @@ func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWBRstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool { // match: (MOVWBRstore [i] {s} p (SRDconst [32] w) x:(MOVWBRstore [i-4] {s} p w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVDBRstore [i-4] {s} p w mem) @@ -13015,9 +13203,7 @@ func rewriteValueS390X_OpS390XMOVWBRstore(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWBRstoreidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVWBRstoreidx(v *Value) bool { // match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} p idx w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVDBRstoreidx [i-4] {s} p idx w mem) @@ -13121,9 +13307,7 @@ func rewriteValueS390X_OpS390XMOVWBRstoreidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWZload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVWZload(v *Value) bool { // match: (MOVWZload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: (MOVWZreg x) @@ -13245,9 +13429,7 @@ func rewriteValueS390X_OpS390XMOVWZload(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWZloadidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVWZloadidx(v *Value) bool { // match: (MOVWZloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (MOVWZloadidx [c+d] {sym} ptr idx mem) @@ -13294,7 +13476,7 @@ func rewriteValueS390X_OpS390XMOVWZloadidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWZreg(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMOVWZreg(v *Value) bool { b := v.Block _ = b // match: (MOVWZreg x:(MOVBZload _ _)) @@ -13452,9 +13634,7 @@ func rewriteValueS390X_OpS390XMOVWZreg(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWload(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVWload(v *Value) bool { // match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (MOVWload [off1+off2] {sym} ptr mem) @@ -13504,7 +13684,7 @@ func rewriteValueS390X_OpS390XMOVWload(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWreg(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMOVWreg(v *Value) bool { b := v.Block _ = b // match: (MOVWreg x:(MOVBload _ _)) @@ -13683,9 +13863,7 @@ func rewriteValueS390X_OpS390XMOVWreg(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWstore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool { // match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem) // cond: // result: (MOVWstore [off] {sym} ptr x mem) @@ -14060,9 +14238,13 @@ func rewriteValueS390X_OpS390XMOVWstore(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (MOVWstoreconst [sc] {s} (ADDconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -14136,7 +14318,7 @@ func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value, config *Config) bool { v.AuxInt = ValAndOff(a).Off() v.Aux = s v.AddArg(p) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = ValAndOff(c).Val()&0xffffffff | ValAndOff(a).Val()<<32 v.AddArg(v0) v.AddArg(mem) @@ -14144,9 +14326,7 @@ func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value) bool { // match: (MOVWstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (MOVWstoreidx [c+d] {sym} ptr idx val mem) @@ -14298,9 +14478,7 @@ func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMULLD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMULLD(v *Value) bool { // match: (MULLD x (MOVDconst [c])) // cond: is32Bit(c) // result: (MULLDconst [c] x) @@ -14391,7 +14569,7 @@ func rewriteValueS390X_OpS390XMULLD(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMULLDconst(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool { b := v.Block _ = b // match: (MULLDconst [-1] x) @@ -14494,9 +14672,7 @@ func rewriteValueS390X_OpS390XMULLDconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMULLW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMULLW(v *Value) bool { // match: (MULLW x (MOVDconst [c])) // cond: // result: (MULLWconst [c] x) @@ -14633,7 +14809,7 @@ func rewriteValueS390X_OpS390XMULLW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XMULLWconst(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool { b := v.Block _ = b // match: (MULLWconst [-1] x) @@ -14736,9 +14912,7 @@ func rewriteValueS390X_OpS390XMULLWconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XNEG(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XNEG(v *Value) bool { // match: (NEG (MOVDconst [c])) // cond: // result: (MOVDconst [-c]) @@ -14776,9 +14950,7 @@ func rewriteValueS390X_OpS390XNEG(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XNEGW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XNEGW(v *Value) bool { // match: (NEGW (MOVDconst [c])) // cond: // result: (MOVDconst [int64(int32(-c))]) @@ -14794,9 +14966,13 @@ func rewriteValueS390X_OpS390XNEGW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XNOT(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XNOT(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (NOT x) // cond: true // result: (XOR (MOVDconst [-1]) x) @@ -14806,7 +14982,7 @@ func rewriteValueS390X_OpS390XNOT(v *Value, config *Config) bool { break } v.reset(OpS390XXOR) - v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64()) v0.AuxInt = -1 v.AddArg(v0) v.AddArg(x) @@ -14814,9 +14990,7 @@ func rewriteValueS390X_OpS390XNOT(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XNOTW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XNOTW(v *Value) bool { // match: (NOTW x) // cond: true // result: (XORWconst [-1] x) @@ -14832,9 +15006,13 @@ func rewriteValueS390X_OpS390XNOTW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XOR(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XOR(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (OR x (MOVDconst [c])) // cond: isU32Bit(c) // result: (ORconst [c] x) @@ -15222,7 +15400,7 @@ func rewriteValueS390X_OpS390XOR(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7) - v0 := b.NewValue0(v.Pos, OpS390XMOVDBRload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDBRload, fe.TypeUInt64()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i @@ -15665,7 +15843,7 @@ func rewriteValueS390X_OpS390XOR(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7) - v0 := b.NewValue0(v.Pos, OpS390XMOVDload, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i - 7 @@ -15909,9 +16087,13 @@ func rewriteValueS390X_OpS390XOR(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XORW(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XORW(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ORW x (MOVDconst [c])) // cond: // result: (ORWconst [c] x) @@ -16165,10 +16347,10 @@ func rewriteValueS390X_OpS390XORW(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1) - v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v.reset(OpCopy) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpS390XMOVHBRload, config.fe.TypeUInt16()) + v1 := b.NewValue0(v.Pos, OpS390XMOVHBRload, fe.TypeUInt16()) v1.AuxInt = i v1.Aux = s v1.AddArg(p) @@ -16246,7 +16428,7 @@ func rewriteValueS390X_OpS390XORW(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1, x2) - v0 := b.NewValue0(v.Pos, OpS390XMOVWBRload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpS390XMOVWBRload, fe.TypeUInt32()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i @@ -16298,7 +16480,7 @@ func rewriteValueS390X_OpS390XORW(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1) - v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64()) v.reset(OpCopy) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, v.Type) @@ -16387,7 +16569,7 @@ func rewriteValueS390X_OpS390XORW(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1, x2) - v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64()) v.reset(OpCopy) v.AddArg(v0) v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, v.Type) @@ -16438,7 +16620,7 @@ func rewriteValueS390X_OpS390XORW(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1) - v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i - 1 @@ -16513,7 +16695,7 @@ func rewriteValueS390X_OpS390XORW(v *Value, config *Config) bool { break } b = mergePoint(b, x0, x1, x2) - v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32()) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = i - 2 @@ -16660,9 +16842,7 @@ func rewriteValueS390X_OpS390XORW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XORWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XORWconst(v *Value) bool { // match: (ORWconst [c] x) // cond: int32(c)==0 // result: x @@ -16705,9 +16885,7 @@ func rewriteValueS390X_OpS390XORWconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XORconst(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -16748,9 +16926,7 @@ func rewriteValueS390X_OpS390XORconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSLD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSLD(v *Value) bool { // match: (SLD x (MOVDconst [c])) // cond: // result: (SLDconst [c&63] x) @@ -16786,9 +16962,7 @@ func rewriteValueS390X_OpS390XSLD(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSLW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSLW(v *Value) bool { // match: (SLW x (MOVDconst [c])) // cond: // result: (SLWconst [c&63] x) @@ -16824,9 +16998,7 @@ func rewriteValueS390X_OpS390XSLW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSRAD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSRAD(v *Value) bool { // match: (SRAD x (MOVDconst [c])) // cond: // result: (SRADconst [c&63] x) @@ -16862,9 +17034,7 @@ func rewriteValueS390X_OpS390XSRAD(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSRADconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSRADconst(v *Value) bool { // match: (SRADconst [c] (MOVDconst [d])) // cond: // result: (MOVDconst [d>>uint64(c)]) @@ -16881,9 +17051,7 @@ func rewriteValueS390X_OpS390XSRADconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSRAW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSRAW(v *Value) bool { // match: (SRAW x (MOVDconst [c])) // cond: // result: (SRAWconst [c&63] x) @@ -16919,9 +17087,7 @@ func rewriteValueS390X_OpS390XSRAW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSRAWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool { // match: (SRAWconst [c] (MOVDconst [d])) // cond: // result: (MOVDconst [d>>uint64(c)]) @@ -16938,9 +17104,7 @@ func rewriteValueS390X_OpS390XSRAWconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSRD(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSRD(v *Value) bool { // match: (SRD x (MOVDconst [c])) // cond: // result: (SRDconst [c&63] x) @@ -16976,9 +17140,7 @@ func rewriteValueS390X_OpS390XSRD(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSRW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSRW(v *Value) bool { // match: (SRW x (MOVDconst [c])) // cond: // result: (SRWconst [c&63] x) @@ -17014,9 +17176,7 @@ func rewriteValueS390X_OpS390XSRW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSTM2(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSTM2(v *Value) bool { // match: (STM2 [i] {s} p w2 w3 x:(STM2 [i-8] {s} p w0 w1 mem)) // cond: x.Uses == 1 && is20Bit(i-8) && clobber(x) // result: (STM4 [i-8] {s} p w0 w1 w2 w3 mem) @@ -17085,9 +17245,7 @@ func rewriteValueS390X_OpS390XSTM2(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSTMG2(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSTMG2(v *Value) bool { // match: (STMG2 [i] {s} p w2 w3 x:(STMG2 [i-16] {s} p w0 w1 mem)) // cond: x.Uses == 1 && is20Bit(i-16) && clobber(x) // result: (STMG4 [i-16] {s} p w0 w1 w2 w3 mem) @@ -17129,7 +17287,7 @@ func rewriteValueS390X_OpS390XSTMG2(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSUB(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XSUB(v *Value) bool { b := v.Block _ = b // match: (SUB x (MOVDconst [c])) @@ -17210,9 +17368,7 @@ func rewriteValueS390X_OpS390XSUB(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSUBEWcarrymask(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSUBEWcarrymask(v *Value) bool { // match: (SUBEWcarrymask (FlagEQ)) // cond: // result: (MOVDconst [-1]) @@ -17251,9 +17407,7 @@ func rewriteValueS390X_OpS390XSUBEWcarrymask(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSUBEcarrymask(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSUBEcarrymask(v *Value) bool { // match: (SUBEcarrymask (FlagEQ)) // cond: // result: (MOVDconst [-1]) @@ -17292,7 +17446,7 @@ func rewriteValueS390X_OpS390XSUBEcarrymask(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSUBW(v *Value, config *Config) bool { +func rewriteValueS390X_OpS390XSUBW(v *Value) bool { b := v.Block _ = b // match: (SUBW x (MOVDconst [c])) @@ -17393,9 +17547,7 @@ func rewriteValueS390X_OpS390XSUBW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XSUBWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSUBWconst(v *Value) bool { // match: (SUBWconst [c] x) // cond: int32(c) == 0 // result: x @@ -17422,9 +17574,7 @@ func rewriteValueS390X_OpS390XSUBWconst(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpS390XSUBconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XSUBconst(v *Value) bool { // match: (SUBconst [0] x) // cond: // result: x @@ -17487,9 +17637,7 @@ func rewriteValueS390X_OpS390XSUBconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XXOR(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XXOR(v *Value) bool { // match: (XOR x (MOVDconst [c])) // cond: isU32Bit(c) // result: (XORconst [c] x) @@ -17660,9 +17808,7 @@ func rewriteValueS390X_OpS390XXOR(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XXORW(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XXORW(v *Value) bool { // match: (XORW x (MOVDconst [c])) // cond: // result: (XORWconst [c] x) @@ -17861,9 +18007,7 @@ func rewriteValueS390X_OpS390XXORW(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XXORWconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XXORWconst(v *Value) bool { // match: (XORWconst [c] x) // cond: int32(c)==0 // result: x @@ -17894,9 +18038,7 @@ func rewriteValueS390X_OpS390XXORWconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpS390XXORconst(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XXORconst(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -17926,7 +18068,7 @@ func rewriteValueS390X_OpS390XXORconst(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpSelect0(v *Value, config *Config) bool { +func rewriteValueS390X_OpSelect0(v *Value) bool { b := v.Block _ = b // match: (Select0 <t> (AddTupleFirst32 tuple val)) @@ -17967,9 +18109,7 @@ func rewriteValueS390X_OpSelect0(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpSelect1(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSelect1(v *Value) bool { // match: (Select1 (AddTupleFirst32 tuple _ )) // cond: // result: (Select1 tuple) @@ -17998,9 +18138,7 @@ func rewriteValueS390X_OpSelect1(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpSignExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSignExt16to32(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -18011,9 +18149,7 @@ func rewriteValueS390X_OpSignExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSignExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSignExt16to64(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVHreg x) @@ -18024,9 +18160,7 @@ func rewriteValueS390X_OpSignExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSignExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSignExt32to64(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVWreg x) @@ -18037,9 +18171,7 @@ func rewriteValueS390X_OpSignExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSignExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSignExt8to16(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -18050,9 +18182,7 @@ func rewriteValueS390X_OpSignExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSignExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSignExt8to32(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -18063,9 +18193,7 @@ func rewriteValueS390X_OpSignExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSignExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSignExt8to64(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBreg x) @@ -18076,7 +18204,7 @@ func rewriteValueS390X_OpSignExt8to64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSlicemask(v *Value, config *Config) bool { +func rewriteValueS390X_OpSlicemask(v *Value) bool { b := v.Block _ = b // match: (Slicemask <t> x) @@ -18093,9 +18221,7 @@ func rewriteValueS390X_OpSlicemask(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSqrt(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSqrt(v *Value) bool { // match: (Sqrt x) // cond: // result: (FSQRT x) @@ -18106,9 +18232,7 @@ func rewriteValueS390X_OpSqrt(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpStaticCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpStaticCall(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -18123,9 +18247,7 @@ func rewriteValueS390X_OpStaticCall(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpStore(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpStore(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type) // result: (FMOVDstore ptr val mem) @@ -18230,9 +18352,7 @@ func rewriteValueS390X_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpSub16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSub16(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUBW x y) @@ -18245,9 +18365,7 @@ func rewriteValueS390X_OpSub16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSub32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSub32(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUBW x y) @@ -18260,9 +18378,7 @@ func rewriteValueS390X_OpSub32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSub32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSub32F(v *Value) bool { // match: (Sub32F x y) // cond: // result: (FSUBS x y) @@ -18275,9 +18391,7 @@ func rewriteValueS390X_OpSub32F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSub64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSub64(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUB x y) @@ -18290,9 +18404,7 @@ func rewriteValueS390X_OpSub64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSub64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSub64F(v *Value) bool { // match: (Sub64F x y) // cond: // result: (FSUB x y) @@ -18305,9 +18417,7 @@ func rewriteValueS390X_OpSub64F(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSub8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSub8(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUBW x y) @@ -18320,9 +18430,7 @@ func rewriteValueS390X_OpSub8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpSubPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpSubPtr(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -18335,9 +18443,7 @@ func rewriteValueS390X_OpSubPtr(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpTrunc16to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpTrunc16to8(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -18349,9 +18455,7 @@ func rewriteValueS390X_OpTrunc16to8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpTrunc32to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpTrunc32to16(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -18363,9 +18467,7 @@ func rewriteValueS390X_OpTrunc32to16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpTrunc32to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpTrunc32to8(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -18377,9 +18479,7 @@ func rewriteValueS390X_OpTrunc32to8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpTrunc64to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpTrunc64to16(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: x @@ -18391,9 +18491,7 @@ func rewriteValueS390X_OpTrunc64to16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpTrunc64to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpTrunc64to32(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: x @@ -18405,9 +18503,7 @@ func rewriteValueS390X_OpTrunc64to32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpTrunc64to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpTrunc64to8(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: x @@ -18419,9 +18515,7 @@ func rewriteValueS390X_OpTrunc64to8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpXor16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpXor16(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XORW x y) @@ -18434,9 +18528,7 @@ func rewriteValueS390X_OpXor16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpXor32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpXor32(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XORW x y) @@ -18449,9 +18541,7 @@ func rewriteValueS390X_OpXor32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpXor64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpXor64(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XOR x y) @@ -18464,9 +18554,7 @@ func rewriteValueS390X_OpXor64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpXor8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpXor8(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XORW x y) @@ -18479,7 +18567,7 @@ func rewriteValueS390X_OpXor8(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpZero(v *Value, config *Config) bool { +func rewriteValueS390X_OpZero(v *Value) bool { b := v.Block _ = b // match: (Zero [0] _ mem) @@ -18669,9 +18757,7 @@ func rewriteValueS390X_OpZero(v *Value, config *Config) bool { } return false } -func rewriteValueS390X_OpZeroExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpZeroExt16to32(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHZreg x) @@ -18682,9 +18768,7 @@ func rewriteValueS390X_OpZeroExt16to32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpZeroExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpZeroExt16to64(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVHZreg x) @@ -18695,9 +18779,7 @@ func rewriteValueS390X_OpZeroExt16to64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpZeroExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpZeroExt32to64(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVWZreg x) @@ -18708,9 +18790,7 @@ func rewriteValueS390X_OpZeroExt32to64(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpZeroExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpZeroExt8to16(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBZreg x) @@ -18721,9 +18801,7 @@ func rewriteValueS390X_OpZeroExt8to16(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpZeroExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpZeroExt8to32(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBZreg x) @@ -18734,9 +18812,7 @@ func rewriteValueS390X_OpZeroExt8to32(v *Value, config *Config) bool { return true } } -func rewriteValueS390X_OpZeroExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpZeroExt8to64(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBZreg x) @@ -18747,7 +18823,11 @@ func rewriteValueS390X_OpZeroExt8to64(v *Value, config *Config) bool { return true } } -func rewriteBlockS390X(b *Block, config *Config) bool { +func rewriteBlockS390X(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { case BlockS390XEQ: // match: (EQ (InvertFlags cmp) yes no) @@ -19203,7 +19283,7 @@ func rewriteBlockS390X(b *Block, config *Config) bool { } // match: (If cond yes no) // cond: - // result: (NE (CMPWconst [0] (MOVBZreg <config.fe.TypeBool()> cond)) yes no) + // result: (NE (CMPWconst [0] (MOVBZreg <fe.TypeBool()> cond)) yes no) for { v := b.Control _ = v @@ -19213,7 +19293,7 @@ func rewriteBlockS390X(b *Block, config *Config) bool { b.Kind = BlockS390XNE v0 := b.NewValue0(v.Pos, OpS390XCMPWconst, TypeFlags) v0.AuxInt = 0 - v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, config.fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeBool()) v1.AddArg(cond) v0.AddArg(v1) b.SetControl(v0) diff --git a/src/cmd/compile/internal/ssa/rewritedec.go b/src/cmd/compile/internal/ssa/rewritedec.go index 7da5162db3..7e6acda356 100644 --- a/src/cmd/compile/internal/ssa/rewritedec.go +++ b/src/cmd/compile/internal/ssa/rewritedec.go @@ -6,36 +6,34 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValuedec(v *Value, config *Config) bool { +func rewriteValuedec(v *Value) bool { switch v.Op { case OpComplexImag: - return rewriteValuedec_OpComplexImag(v, config) + return rewriteValuedec_OpComplexImag(v) case OpComplexReal: - return rewriteValuedec_OpComplexReal(v, config) + return rewriteValuedec_OpComplexReal(v) case OpIData: - return rewriteValuedec_OpIData(v, config) + return rewriteValuedec_OpIData(v) case OpITab: - return rewriteValuedec_OpITab(v, config) + return rewriteValuedec_OpITab(v) case OpLoad: - return rewriteValuedec_OpLoad(v, config) + return rewriteValuedec_OpLoad(v) case OpSliceCap: - return rewriteValuedec_OpSliceCap(v, config) + return rewriteValuedec_OpSliceCap(v) case OpSliceLen: - return rewriteValuedec_OpSliceLen(v, config) + return rewriteValuedec_OpSliceLen(v) case OpSlicePtr: - return rewriteValuedec_OpSlicePtr(v, config) + return rewriteValuedec_OpSlicePtr(v) case OpStore: - return rewriteValuedec_OpStore(v, config) + return rewriteValuedec_OpStore(v) case OpStringLen: - return rewriteValuedec_OpStringLen(v, config) + return rewriteValuedec_OpStringLen(v) case OpStringPtr: - return rewriteValuedec_OpStringPtr(v, config) + return rewriteValuedec_OpStringPtr(v) } return false } -func rewriteValuedec_OpComplexImag(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec_OpComplexImag(v *Value) bool { // match: (ComplexImag (ComplexMake _ imag )) // cond: // result: imag @@ -52,9 +50,7 @@ func rewriteValuedec_OpComplexImag(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpComplexReal(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec_OpComplexReal(v *Value) bool { // match: (ComplexReal (ComplexMake real _ )) // cond: // result: real @@ -71,9 +67,7 @@ func rewriteValuedec_OpComplexReal(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpIData(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec_OpIData(v *Value) bool { // match: (IData (IMake _ data)) // cond: // result: data @@ -90,7 +84,7 @@ func rewriteValuedec_OpIData(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpITab(v *Value, config *Config) bool { +func rewriteValuedec_OpITab(v *Value) bool { b := v.Block _ = b // match: (ITab (IMake itab _)) @@ -109,12 +103,16 @@ func rewriteValuedec_OpITab(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpLoad(v *Value, config *Config) bool { +func rewriteValuedec_OpLoad(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Load <t> ptr mem) // cond: t.IsComplex() && t.Size() == 8 - // result: (ComplexMake (Load <config.fe.TypeFloat32()> ptr mem) (Load <config.fe.TypeFloat32()> (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] ptr) mem) ) + // result: (ComplexMake (Load <fe.TypeFloat32()> ptr mem) (Load <fe.TypeFloat32()> (OffPtr <fe.TypeFloat32().PtrTo()> [4] ptr) mem) ) for { t := v.Type ptr := v.Args[0] @@ -123,12 +121,12 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { break } v.reset(OpComplexMake) - v0 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeFloat32()) + v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat32()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeFloat32()) - v2 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeFloat32().PtrTo()) + v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat32()) + v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat32().PtrTo()) v2.AuxInt = 4 v2.AddArg(ptr) v1.AddArg(v2) @@ -138,7 +136,7 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { } // match: (Load <t> ptr mem) // cond: t.IsComplex() && t.Size() == 16 - // result: (ComplexMake (Load <config.fe.TypeFloat64()> ptr mem) (Load <config.fe.TypeFloat64()> (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] ptr) mem) ) + // result: (ComplexMake (Load <fe.TypeFloat64()> ptr mem) (Load <fe.TypeFloat64()> (OffPtr <fe.TypeFloat64().PtrTo()> [8] ptr) mem) ) for { t := v.Type ptr := v.Args[0] @@ -147,12 +145,12 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { break } v.reset(OpComplexMake) - v0 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeFloat64()) + v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat64()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeFloat64()) - v2 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeFloat64().PtrTo()) + v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat64()) + v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat64().PtrTo()) v2.AuxInt = 8 v2.AddArg(ptr) v1.AddArg(v2) @@ -162,7 +160,7 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { } // match: (Load <t> ptr mem) // cond: t.IsString() - // result: (StringMake (Load <config.fe.TypeBytePtr()> ptr mem) (Load <config.fe.TypeInt()> (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem)) + // result: (StringMake (Load <fe.TypeBytePtr()> ptr mem) (Load <fe.TypeInt()> (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem)) for { t := v.Type ptr := v.Args[0] @@ -171,12 +169,12 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { break } v.reset(OpStringMake) - v0 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeBytePtr()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeInt()) - v2 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt().PtrTo()) + v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt()) + v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v2.AuxInt = config.PtrSize v2.AddArg(ptr) v1.AddArg(v2) @@ -186,7 +184,7 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { } // match: (Load <t> ptr mem) // cond: t.IsSlice() - // result: (SliceMake (Load <t.ElemType().PtrTo()> ptr mem) (Load <config.fe.TypeInt()> (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem) (Load <config.fe.TypeInt()> (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr) mem)) + // result: (SliceMake (Load <t.ElemType().PtrTo()> ptr mem) (Load <fe.TypeInt()> (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem) (Load <fe.TypeInt()> (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr) mem)) for { t := v.Type ptr := v.Args[0] @@ -199,15 +197,15 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeInt()) - v2 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt().PtrTo()) + v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt()) + v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v2.AuxInt = config.PtrSize v2.AddArg(ptr) v1.AddArg(v2) v1.AddArg(mem) v.AddArg(v1) - v3 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeInt()) - v4 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt().PtrTo()) + v3 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt()) + v4 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v4.AuxInt = 2 * config.PtrSize v4.AddArg(ptr) v3.AddArg(v4) @@ -217,7 +215,7 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { } // match: (Load <t> ptr mem) // cond: t.IsInterface() - // result: (IMake (Load <config.fe.TypeBytePtr()> ptr mem) (Load <config.fe.TypeBytePtr()> (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr) mem)) + // result: (IMake (Load <fe.TypeBytePtr()> ptr mem) (Load <fe.TypeBytePtr()> (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr) mem)) for { t := v.Type ptr := v.Args[0] @@ -226,12 +224,12 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { break } v.reset(OpIMake) - v0 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeBytePtr()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeBytePtr()) - v2 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeBytePtr().PtrTo()) + v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeBytePtr()) + v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeBytePtr().PtrTo()) v2.AuxInt = config.PtrSize v2.AddArg(ptr) v1.AddArg(v2) @@ -241,9 +239,7 @@ func rewriteValuedec_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpSliceCap(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec_OpSliceCap(v *Value) bool { // match: (SliceCap (SliceMake _ _ cap)) // cond: // result: cap @@ -260,9 +256,7 @@ func rewriteValuedec_OpSliceCap(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpSliceLen(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec_OpSliceLen(v *Value) bool { // match: (SliceLen (SliceMake _ len _)) // cond: // result: len @@ -279,9 +273,7 @@ func rewriteValuedec_OpSliceLen(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpSlicePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec_OpSlicePtr(v *Value) bool { // match: (SlicePtr (SliceMake ptr _ _ )) // cond: // result: ptr @@ -298,12 +290,16 @@ func rewriteValuedec_OpSlicePtr(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpStore(v *Value, config *Config) bool { +func rewriteValuedec_OpStore(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Store {t} dst (ComplexMake real imag) mem) // cond: t.(Type).Size() == 8 - // result: (Store {config.fe.TypeFloat32()} (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] dst) imag (Store {config.fe.TypeFloat32()} dst real mem)) + // result: (Store {fe.TypeFloat32()} (OffPtr <fe.TypeFloat32().PtrTo()> [4] dst) imag (Store {fe.TypeFloat32()} dst real mem)) for { t := v.Aux dst := v.Args[0] @@ -318,14 +314,14 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { break } v.reset(OpStore) - v.Aux = config.fe.TypeFloat32() - v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeFloat32().PtrTo()) + v.Aux = fe.TypeFloat32() + v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat32().PtrTo()) v0.AuxInt = 4 v0.AddArg(dst) v.AddArg(v0) v.AddArg(imag) v1 := b.NewValue0(v.Pos, OpStore, TypeMem) - v1.Aux = config.fe.TypeFloat32() + v1.Aux = fe.TypeFloat32() v1.AddArg(dst) v1.AddArg(real) v1.AddArg(mem) @@ -334,7 +330,7 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { } // match: (Store {t} dst (ComplexMake real imag) mem) // cond: t.(Type).Size() == 16 - // result: (Store {config.fe.TypeFloat64()} (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] dst) imag (Store {config.fe.TypeFloat64()} dst real mem)) + // result: (Store {fe.TypeFloat64()} (OffPtr <fe.TypeFloat64().PtrTo()> [8] dst) imag (Store {fe.TypeFloat64()} dst real mem)) for { t := v.Aux dst := v.Args[0] @@ -349,14 +345,14 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { break } v.reset(OpStore) - v.Aux = config.fe.TypeFloat64() - v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeFloat64().PtrTo()) + v.Aux = fe.TypeFloat64() + v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat64().PtrTo()) v0.AuxInt = 8 v0.AddArg(dst) v.AddArg(v0) v.AddArg(imag) v1 := b.NewValue0(v.Pos, OpStore, TypeMem) - v1.Aux = config.fe.TypeFloat64() + v1.Aux = fe.TypeFloat64() v1.AddArg(dst) v1.AddArg(real) v1.AddArg(mem) @@ -365,7 +361,7 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { } // match: (Store dst (StringMake ptr len) mem) // cond: - // result: (Store {config.fe.TypeInt()} (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {config.fe.TypeBytePtr()} dst ptr mem)) + // result: (Store {fe.TypeInt()} (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {fe.TypeBytePtr()} dst ptr mem)) for { dst := v.Args[0] v_1 := v.Args[1] @@ -376,14 +372,14 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { len := v_1.Args[1] mem := v.Args[2] v.reset(OpStore) - v.Aux = config.fe.TypeInt() - v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt().PtrTo()) + v.Aux = fe.TypeInt() + v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v0.AuxInt = config.PtrSize v0.AddArg(dst) v.AddArg(v0) v.AddArg(len) v1 := b.NewValue0(v.Pos, OpStore, TypeMem) - v1.Aux = config.fe.TypeBytePtr() + v1.Aux = fe.TypeBytePtr() v1.AddArg(dst) v1.AddArg(ptr) v1.AddArg(mem) @@ -392,7 +388,7 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { } // match: (Store dst (SliceMake ptr len cap) mem) // cond: - // result: (Store {config.fe.TypeInt()} (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) cap (Store {config.fe.TypeInt()} (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {config.fe.TypeBytePtr()} dst ptr mem))) + // result: (Store {fe.TypeInt()} (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) cap (Store {fe.TypeInt()} (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {fe.TypeBytePtr()} dst ptr mem))) for { dst := v.Args[0] v_1 := v.Args[1] @@ -404,21 +400,21 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { cap := v_1.Args[2] mem := v.Args[2] v.reset(OpStore) - v.Aux = config.fe.TypeInt() - v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt().PtrTo()) + v.Aux = fe.TypeInt() + v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v0.AuxInt = 2 * config.PtrSize v0.AddArg(dst) v.AddArg(v0) v.AddArg(cap) v1 := b.NewValue0(v.Pos, OpStore, TypeMem) - v1.Aux = config.fe.TypeInt() - v2 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt().PtrTo()) + v1.Aux = fe.TypeInt() + v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v2.AuxInt = config.PtrSize v2.AddArg(dst) v1.AddArg(v2) v1.AddArg(len) v3 := b.NewValue0(v.Pos, OpStore, TypeMem) - v3.Aux = config.fe.TypeBytePtr() + v3.Aux = fe.TypeBytePtr() v3.AddArg(dst) v3.AddArg(ptr) v3.AddArg(mem) @@ -428,7 +424,7 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { } // match: (Store dst (IMake itab data) mem) // cond: - // result: (Store {config.fe.TypeBytePtr()} (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) data (Store {config.fe.TypeUintptr()} dst itab mem)) + // result: (Store {fe.TypeBytePtr()} (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) data (Store {fe.TypeUintptr()} dst itab mem)) for { dst := v.Args[0] v_1 := v.Args[1] @@ -439,14 +435,14 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { data := v_1.Args[1] mem := v.Args[2] v.reset(OpStore) - v.Aux = config.fe.TypeBytePtr() - v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeBytePtr().PtrTo()) + v.Aux = fe.TypeBytePtr() + v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeBytePtr().PtrTo()) v0.AuxInt = config.PtrSize v0.AddArg(dst) v.AddArg(v0) v.AddArg(data) v1 := b.NewValue0(v.Pos, OpStore, TypeMem) - v1.Aux = config.fe.TypeUintptr() + v1.Aux = fe.TypeUintptr() v1.AddArg(dst) v1.AddArg(itab) v1.AddArg(mem) @@ -455,9 +451,7 @@ func rewriteValuedec_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpStringLen(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec_OpStringLen(v *Value) bool { // match: (StringLen (StringMake _ len)) // cond: // result: len @@ -474,9 +468,7 @@ func rewriteValuedec_OpStringLen(v *Value, config *Config) bool { } return false } -func rewriteValuedec_OpStringPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec_OpStringPtr(v *Value) bool { // match: (StringPtr (StringMake ptr _)) // cond: // result: ptr @@ -493,7 +485,11 @@ func rewriteValuedec_OpStringPtr(v *Value, config *Config) bool { } return false } -func rewriteBlockdec(b *Block, config *Config) bool { +func rewriteBlockdec(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { } return false diff --git a/src/cmd/compile/internal/ssa/rewritedec64.go b/src/cmd/compile/internal/ssa/rewritedec64.go index 7a4ba21b6a..ccb511d2ca 100644 --- a/src/cmd/compile/internal/ssa/rewritedec64.go +++ b/src/cmd/compile/internal/ssa/rewritedec64.go @@ -6,159 +6,163 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValuedec64(v *Value, config *Config) bool { +func rewriteValuedec64(v *Value) bool { switch v.Op { case OpAdd64: - return rewriteValuedec64_OpAdd64(v, config) + return rewriteValuedec64_OpAdd64(v) case OpAnd64: - return rewriteValuedec64_OpAnd64(v, config) + return rewriteValuedec64_OpAnd64(v) case OpArg: - return rewriteValuedec64_OpArg(v, config) + return rewriteValuedec64_OpArg(v) case OpBitLen64: - return rewriteValuedec64_OpBitLen64(v, config) + return rewriteValuedec64_OpBitLen64(v) case OpBswap64: - return rewriteValuedec64_OpBswap64(v, config) + return rewriteValuedec64_OpBswap64(v) case OpCom64: - return rewriteValuedec64_OpCom64(v, config) + return rewriteValuedec64_OpCom64(v) case OpConst64: - return rewriteValuedec64_OpConst64(v, config) + return rewriteValuedec64_OpConst64(v) case OpCtz64: - return rewriteValuedec64_OpCtz64(v, config) + return rewriteValuedec64_OpCtz64(v) case OpEq64: - return rewriteValuedec64_OpEq64(v, config) + return rewriteValuedec64_OpEq64(v) case OpGeq64: - return rewriteValuedec64_OpGeq64(v, config) + return rewriteValuedec64_OpGeq64(v) case OpGeq64U: - return rewriteValuedec64_OpGeq64U(v, config) + return rewriteValuedec64_OpGeq64U(v) case OpGreater64: - return rewriteValuedec64_OpGreater64(v, config) + return rewriteValuedec64_OpGreater64(v) case OpGreater64U: - return rewriteValuedec64_OpGreater64U(v, config) + return rewriteValuedec64_OpGreater64U(v) case OpInt64Hi: - return rewriteValuedec64_OpInt64Hi(v, config) + return rewriteValuedec64_OpInt64Hi(v) case OpInt64Lo: - return rewriteValuedec64_OpInt64Lo(v, config) + return rewriteValuedec64_OpInt64Lo(v) case OpLeq64: - return rewriteValuedec64_OpLeq64(v, config) + return rewriteValuedec64_OpLeq64(v) case OpLeq64U: - return rewriteValuedec64_OpLeq64U(v, config) + return rewriteValuedec64_OpLeq64U(v) case OpLess64: - return rewriteValuedec64_OpLess64(v, config) + return rewriteValuedec64_OpLess64(v) case OpLess64U: - return rewriteValuedec64_OpLess64U(v, config) + return rewriteValuedec64_OpLess64U(v) case OpLoad: - return rewriteValuedec64_OpLoad(v, config) + return rewriteValuedec64_OpLoad(v) case OpLsh16x64: - return rewriteValuedec64_OpLsh16x64(v, config) + return rewriteValuedec64_OpLsh16x64(v) case OpLsh32x64: - return rewriteValuedec64_OpLsh32x64(v, config) + return rewriteValuedec64_OpLsh32x64(v) case OpLsh64x16: - return rewriteValuedec64_OpLsh64x16(v, config) + return rewriteValuedec64_OpLsh64x16(v) case OpLsh64x32: - return rewriteValuedec64_OpLsh64x32(v, config) + return rewriteValuedec64_OpLsh64x32(v) case OpLsh64x64: - return rewriteValuedec64_OpLsh64x64(v, config) + return rewriteValuedec64_OpLsh64x64(v) case OpLsh64x8: - return rewriteValuedec64_OpLsh64x8(v, config) + return rewriteValuedec64_OpLsh64x8(v) case OpLsh8x64: - return rewriteValuedec64_OpLsh8x64(v, config) + return rewriteValuedec64_OpLsh8x64(v) case OpMul64: - return rewriteValuedec64_OpMul64(v, config) + return rewriteValuedec64_OpMul64(v) case OpNeg64: - return rewriteValuedec64_OpNeg64(v, config) + return rewriteValuedec64_OpNeg64(v) case OpNeq64: - return rewriteValuedec64_OpNeq64(v, config) + return rewriteValuedec64_OpNeq64(v) case OpOr64: - return rewriteValuedec64_OpOr64(v, config) + return rewriteValuedec64_OpOr64(v) case OpRsh16Ux64: - return rewriteValuedec64_OpRsh16Ux64(v, config) + return rewriteValuedec64_OpRsh16Ux64(v) case OpRsh16x64: - return rewriteValuedec64_OpRsh16x64(v, config) + return rewriteValuedec64_OpRsh16x64(v) case OpRsh32Ux64: - return rewriteValuedec64_OpRsh32Ux64(v, config) + return rewriteValuedec64_OpRsh32Ux64(v) case OpRsh32x64: - return rewriteValuedec64_OpRsh32x64(v, config) + return rewriteValuedec64_OpRsh32x64(v) case OpRsh64Ux16: - return rewriteValuedec64_OpRsh64Ux16(v, config) + return rewriteValuedec64_OpRsh64Ux16(v) case OpRsh64Ux32: - return rewriteValuedec64_OpRsh64Ux32(v, config) + return rewriteValuedec64_OpRsh64Ux32(v) case OpRsh64Ux64: - return rewriteValuedec64_OpRsh64Ux64(v, config) + return rewriteValuedec64_OpRsh64Ux64(v) case OpRsh64Ux8: - return rewriteValuedec64_OpRsh64Ux8(v, config) + return rewriteValuedec64_OpRsh64Ux8(v) case OpRsh64x16: - return rewriteValuedec64_OpRsh64x16(v, config) + return rewriteValuedec64_OpRsh64x16(v) case OpRsh64x32: - return rewriteValuedec64_OpRsh64x32(v, config) + return rewriteValuedec64_OpRsh64x32(v) case OpRsh64x64: - return rewriteValuedec64_OpRsh64x64(v, config) + return rewriteValuedec64_OpRsh64x64(v) case OpRsh64x8: - return rewriteValuedec64_OpRsh64x8(v, config) + return rewriteValuedec64_OpRsh64x8(v) case OpRsh8Ux64: - return rewriteValuedec64_OpRsh8Ux64(v, config) + return rewriteValuedec64_OpRsh8Ux64(v) case OpRsh8x64: - return rewriteValuedec64_OpRsh8x64(v, config) + return rewriteValuedec64_OpRsh8x64(v) case OpSignExt16to64: - return rewriteValuedec64_OpSignExt16to64(v, config) + return rewriteValuedec64_OpSignExt16to64(v) case OpSignExt32to64: - return rewriteValuedec64_OpSignExt32to64(v, config) + return rewriteValuedec64_OpSignExt32to64(v) case OpSignExt8to64: - return rewriteValuedec64_OpSignExt8to64(v, config) + return rewriteValuedec64_OpSignExt8to64(v) case OpStore: - return rewriteValuedec64_OpStore(v, config) + return rewriteValuedec64_OpStore(v) case OpSub64: - return rewriteValuedec64_OpSub64(v, config) + return rewriteValuedec64_OpSub64(v) case OpTrunc64to16: - return rewriteValuedec64_OpTrunc64to16(v, config) + return rewriteValuedec64_OpTrunc64to16(v) case OpTrunc64to32: - return rewriteValuedec64_OpTrunc64to32(v, config) + return rewriteValuedec64_OpTrunc64to32(v) case OpTrunc64to8: - return rewriteValuedec64_OpTrunc64to8(v, config) + return rewriteValuedec64_OpTrunc64to8(v) case OpXor64: - return rewriteValuedec64_OpXor64(v, config) + return rewriteValuedec64_OpXor64(v) case OpZeroExt16to64: - return rewriteValuedec64_OpZeroExt16to64(v, config) + return rewriteValuedec64_OpZeroExt16to64(v) case OpZeroExt32to64: - return rewriteValuedec64_OpZeroExt32to64(v, config) + return rewriteValuedec64_OpZeroExt32to64(v) case OpZeroExt8to64: - return rewriteValuedec64_OpZeroExt8to64(v, config) + return rewriteValuedec64_OpZeroExt8to64(v) } return false } -func rewriteValuedec64_OpAdd64(v *Value, config *Config) bool { +func rewriteValuedec64_OpAdd64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Add64 x y) // cond: - // result: (Int64Make (Add32withcarry <config.fe.TypeInt32()> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y)))) (Select0 <config.fe.TypeUInt32()> (Add32carry (Int64Lo x) (Int64Lo y)))) + // result: (Int64Make (Add32withcarry <fe.TypeInt32()> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y)))) (Select0 <fe.TypeUInt32()> (Add32carry (Int64Lo x) (Int64Lo y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpAdd32withcarry, config.fe.TypeInt32()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpAdd32withcarry, fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v3 := b.NewValue0(v.Pos, OpSelect1, TypeFlags) - v4 := b.NewValue0(v.Pos, OpAdd32carry, MakeTuple(config.fe.TypeUInt32(), TypeFlags)) - v5 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpAdd32carry, MakeTuple(fe.TypeUInt32(), TypeFlags)) + v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) v0.AddArg(v3) v.AddArg(v0) - v7 := b.NewValue0(v.Pos, OpSelect0, config.fe.TypeUInt32()) - v8 := b.NewValue0(v.Pos, OpAdd32carry, MakeTuple(config.fe.TypeUInt32(), TypeFlags)) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpSelect0, fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpAdd32carry, MakeTuple(fe.TypeUInt32(), TypeFlags)) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(x) v8.AddArg(v9) - v10 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v10 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v10.AddArg(y) v8.AddArg(v10) v7.AddArg(v8) @@ -166,41 +170,49 @@ func rewriteValuedec64_OpAdd64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpAnd64(v *Value, config *Config) bool { +func rewriteValuedec64_OpAnd64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (And64 x y) // cond: - // result: (Int64Make (And32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (And32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) + // result: (Int64Make (And32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (And32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) for { x := v.Args[0] y := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpAnd32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpAnd32, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v4.AddArg(x) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v5.AddArg(y) v3.AddArg(v5) v.AddArg(v3) return true } } -func rewriteValuedec64_OpArg(v *Value, config *Config) bool { +func rewriteValuedec64_OpArg(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Arg {n} [off]) // cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() - // result: (Int64Make (Arg <config.fe.TypeInt32()> {n} [off+4]) (Arg <config.fe.TypeUInt32()> {n} [off])) + // result: (Int64Make (Arg <fe.TypeInt32()> {n} [off+4]) (Arg <fe.TypeUInt32()> {n} [off])) for { off := v.AuxInt n := v.Aux @@ -208,11 +220,11 @@ func rewriteValuedec64_OpArg(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpArg, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpArg, fe.TypeInt32()) v0.AuxInt = off + 4 v0.Aux = n v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpArg, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32()) v1.AuxInt = off v1.Aux = n v.AddArg(v1) @@ -220,7 +232,7 @@ func rewriteValuedec64_OpArg(v *Value, config *Config) bool { } // match: (Arg {n} [off]) // cond: is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() - // result: (Int64Make (Arg <config.fe.TypeUInt32()> {n} [off+4]) (Arg <config.fe.TypeUInt32()> {n} [off])) + // result: (Int64Make (Arg <fe.TypeUInt32()> {n} [off+4]) (Arg <fe.TypeUInt32()> {n} [off])) for { off := v.AuxInt n := v.Aux @@ -228,11 +240,11 @@ func rewriteValuedec64_OpArg(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpArg, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32()) v0.AuxInt = off + 4 v0.Aux = n v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpArg, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32()) v1.AuxInt = off v1.Aux = n v.AddArg(v1) @@ -240,7 +252,7 @@ func rewriteValuedec64_OpArg(v *Value, config *Config) bool { } // match: (Arg {n} [off]) // cond: is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() - // result: (Int64Make (Arg <config.fe.TypeInt32()> {n} [off]) (Arg <config.fe.TypeUInt32()> {n} [off+4])) + // result: (Int64Make (Arg <fe.TypeInt32()> {n} [off]) (Arg <fe.TypeUInt32()> {n} [off+4])) for { off := v.AuxInt n := v.Aux @@ -248,11 +260,11 @@ func rewriteValuedec64_OpArg(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpArg, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpArg, fe.TypeInt32()) v0.AuxInt = off v0.Aux = n v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpArg, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32()) v1.AuxInt = off + 4 v1.Aux = n v.AddArg(v1) @@ -260,7 +272,7 @@ func rewriteValuedec64_OpArg(v *Value, config *Config) bool { } // match: (Arg {n} [off]) // cond: is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() - // result: (Int64Make (Arg <config.fe.TypeUInt32()> {n} [off]) (Arg <config.fe.TypeUInt32()> {n} [off+4])) + // result: (Int64Make (Arg <fe.TypeUInt32()> {n} [off]) (Arg <fe.TypeUInt32()> {n} [off+4])) for { off := v.AuxInt n := v.Aux @@ -268,11 +280,11 @@ func rewriteValuedec64_OpArg(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpArg, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32()) v0.AuxInt = off v0.Aux = n v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpArg, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32()) v1.AuxInt = off + 4 v1.Aux = n v.AddArg(v1) @@ -280,28 +292,32 @@ func rewriteValuedec64_OpArg(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpBitLen64(v *Value, config *Config) bool { +func rewriteValuedec64_OpBitLen64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (BitLen64 x) // cond: - // result: (Add32 <config.fe.TypeInt()> (BitLen32 <config.fe.TypeInt()> (Int64Hi x)) (BitLen32 <config.fe.TypeInt()> (Or32 <config.fe.TypeUInt32()> (Int64Lo x) (Zeromask (Int64Hi x))))) + // result: (Add32 <fe.TypeInt()> (BitLen32 <fe.TypeInt()> (Int64Hi x)) (BitLen32 <fe.TypeInt()> (Or32 <fe.TypeUInt32()> (Int64Lo x) (Zeromask (Int64Hi x))))) for { x := v.Args[0] v.reset(OpAdd32) - v.Type = config.fe.TypeInt() - v0 := b.NewValue0(v.Pos, OpBitLen32, config.fe.TypeInt()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v.Type = fe.TypeInt() + v0 := b.NewValue0(v.Pos, OpBitLen32, fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpBitLen32, config.fe.TypeInt()) - v3 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpBitLen32, fe.TypeInt()) + v3 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v4.AddArg(x) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(x) v5.AddArg(v6) v3.AddArg(v5) @@ -310,56 +326,68 @@ func rewriteValuedec64_OpBitLen64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpBswap64(v *Value, config *Config) bool { +func rewriteValuedec64_OpBswap64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Bswap64 x) // cond: - // result: (Int64Make (Bswap32 <config.fe.TypeUInt32()> (Int64Lo x)) (Bswap32 <config.fe.TypeUInt32()> (Int64Hi x))) + // result: (Int64Make (Bswap32 <fe.TypeUInt32()> (Int64Lo x)) (Bswap32 <fe.TypeUInt32()> (Int64Hi x))) for { x := v.Args[0] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpBswap32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpBswap32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpBswap32, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpBswap32, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v3.AddArg(x) v2.AddArg(v3) v.AddArg(v2) return true } } -func rewriteValuedec64_OpCom64(v *Value, config *Config) bool { +func rewriteValuedec64_OpCom64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Com64 x) // cond: - // result: (Int64Make (Com32 <config.fe.TypeUInt32()> (Int64Hi x)) (Com32 <config.fe.TypeUInt32()> (Int64Lo x))) + // result: (Int64Make (Com32 <fe.TypeUInt32()> (Int64Hi x)) (Com32 <fe.TypeUInt32()> (Int64Lo x))) for { x := v.Args[0] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpCom32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpCom32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpCom32, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpCom32, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v3.AddArg(x) v2.AddArg(v3) v.AddArg(v2) return true } } -func rewriteValuedec64_OpConst64(v *Value, config *Config) bool { +func rewriteValuedec64_OpConst64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Const64 <t> [c]) // cond: t.IsSigned() - // result: (Int64Make (Const32 <config.fe.TypeInt32()> [c>>32]) (Const32 <config.fe.TypeUInt32()> [int64(int32(c))])) + // result: (Int64Make (Const32 <fe.TypeInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))])) for { t := v.Type c := v.AuxInt @@ -367,17 +395,17 @@ func rewriteValuedec64_OpConst64(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt32()) v0.AuxInt = c >> 32 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v1.AuxInt = int64(int32(c)) v.AddArg(v1) return true } // match: (Const64 <t> [c]) // cond: !t.IsSigned() - // result: (Int64Make (Const32 <config.fe.TypeUInt32()> [c>>32]) (Const32 <config.fe.TypeUInt32()> [int64(int32(c))])) + // result: (Int64Make (Const32 <fe.TypeUInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))])) for { t := v.Type c := v.AuxInt @@ -385,41 +413,45 @@ func rewriteValuedec64_OpConst64(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v0.AuxInt = c >> 32 v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v1.AuxInt = int64(int32(c)) v.AddArg(v1) return true } return false } -func rewriteValuedec64_OpCtz64(v *Value, config *Config) bool { +func rewriteValuedec64_OpCtz64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Ctz64 x) // cond: - // result: (Add32 <config.fe.TypeUInt32()> (Ctz32 <config.fe.TypeUInt32()> (Int64Lo x)) (And32 <config.fe.TypeUInt32()> (Com32 <config.fe.TypeUInt32()> (Zeromask (Int64Lo x))) (Ctz32 <config.fe.TypeUInt32()> (Int64Hi x)))) + // result: (Add32 <fe.TypeUInt32()> (Ctz32 <fe.TypeUInt32()> (Int64Lo x)) (And32 <fe.TypeUInt32()> (Com32 <fe.TypeUInt32()> (Zeromask (Int64Lo x))) (Ctz32 <fe.TypeUInt32()> (Int64Hi x)))) for { x := v.Args[0] v.reset(OpAdd32) - v.Type = config.fe.TypeUInt32() - v0 := b.NewValue0(v.Pos, OpCtz32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v.Type = fe.TypeUInt32() + v0 := b.NewValue0(v.Pos, OpCtz32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpAnd32, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpCom32, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) - v5 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpCom32, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) v3.AddArg(v4) v2.AddArg(v3) - v6 := b.NewValue0(v.Pos, OpCtz32, config.fe.TypeUInt32()) - v7 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpCtz32, fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v7.AddArg(x) v6.AddArg(v7) v2.AddArg(v6) @@ -427,9 +459,13 @@ func rewriteValuedec64_OpCtz64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpEq64(v *Value, config *Config) bool { +func rewriteValuedec64_OpEq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Eq64 x y) // cond: // result: (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Eq32 (Int64Lo x) (Int64Lo y))) @@ -437,28 +473,32 @@ func rewriteValuedec64_OpEq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpAndB) - v0 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v4.AddArg(x) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v5.AddArg(y) v3.AddArg(v5) v.AddArg(v3) return true } } -func rewriteValuedec64_OpGeq64(v *Value, config *Config) bool { +func rewriteValuedec64_OpGeq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq64 x y) // cond: // result: (OrB (Greater32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Geq32U (Int64Lo x) (Int64Lo y)))) @@ -466,28 +506,28 @@ func rewriteValuedec64_OpGeq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpOrB) - v0 := b.NewValue0(v.Pos, OpGreater32, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpGreater32, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpAndB, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v5 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) - v7 := b.NewValue0(v.Pos, OpGeq32U, config.fe.TypeBool()) - v8 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpGeq32U, fe.TypeBool()) + v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v8.AddArg(x) v7.AddArg(v8) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(y) v7.AddArg(v9) v3.AddArg(v7) @@ -495,9 +535,13 @@ func rewriteValuedec64_OpGeq64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpGeq64U(v *Value, config *Config) bool { +func rewriteValuedec64_OpGeq64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Geq64U x y) // cond: // result: (OrB (Greater32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Geq32U (Int64Lo x) (Int64Lo y)))) @@ -505,28 +549,28 @@ func rewriteValuedec64_OpGeq64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpOrB) - v0 := b.NewValue0(v.Pos, OpGreater32U, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpGreater32U, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpAndB, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v5 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) - v7 := b.NewValue0(v.Pos, OpGeq32U, config.fe.TypeBool()) - v8 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpGeq32U, fe.TypeBool()) + v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v8.AddArg(x) v7.AddArg(v8) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(y) v7.AddArg(v9) v3.AddArg(v7) @@ -534,9 +578,13 @@ func rewriteValuedec64_OpGeq64U(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpGreater64(v *Value, config *Config) bool { +func rewriteValuedec64_OpGreater64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater64 x y) // cond: // result: (OrB (Greater32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Greater32U (Int64Lo x) (Int64Lo y)))) @@ -544,28 +592,28 @@ func rewriteValuedec64_OpGreater64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpOrB) - v0 := b.NewValue0(v.Pos, OpGreater32, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpGreater32, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpAndB, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v5 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) - v7 := b.NewValue0(v.Pos, OpGreater32U, config.fe.TypeBool()) - v8 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpGreater32U, fe.TypeBool()) + v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v8.AddArg(x) v7.AddArg(v8) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(y) v7.AddArg(v9) v3.AddArg(v7) @@ -573,9 +621,13 @@ func rewriteValuedec64_OpGreater64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpGreater64U(v *Value, config *Config) bool { +func rewriteValuedec64_OpGreater64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Greater64U x y) // cond: // result: (OrB (Greater32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Greater32U (Int64Lo x) (Int64Lo y)))) @@ -583,28 +635,28 @@ func rewriteValuedec64_OpGreater64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpOrB) - v0 := b.NewValue0(v.Pos, OpGreater32U, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpGreater32U, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpAndB, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v5 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) - v7 := b.NewValue0(v.Pos, OpGreater32U, config.fe.TypeBool()) - v8 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpGreater32U, fe.TypeBool()) + v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v8.AddArg(x) v7.AddArg(v8) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(y) v7.AddArg(v9) v3.AddArg(v7) @@ -612,9 +664,7 @@ func rewriteValuedec64_OpGreater64U(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpInt64Hi(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec64_OpInt64Hi(v *Value) bool { // match: (Int64Hi (Int64Make hi _)) // cond: // result: hi @@ -631,9 +681,7 @@ func rewriteValuedec64_OpInt64Hi(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpInt64Lo(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec64_OpInt64Lo(v *Value) bool { // match: (Int64Lo (Int64Make _ lo)) // cond: // result: lo @@ -650,9 +698,13 @@ func rewriteValuedec64_OpInt64Lo(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpLeq64(v *Value, config *Config) bool { +func rewriteValuedec64_OpLeq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq64 x y) // cond: // result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y)))) @@ -660,28 +712,28 @@ func rewriteValuedec64_OpLeq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpOrB) - v0 := b.NewValue0(v.Pos, OpLess32, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpLess32, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpAndB, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v5 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) - v7 := b.NewValue0(v.Pos, OpLeq32U, config.fe.TypeBool()) - v8 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpLeq32U, fe.TypeBool()) + v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v8.AddArg(x) v7.AddArg(v8) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(y) v7.AddArg(v9) v3.AddArg(v7) @@ -689,9 +741,13 @@ func rewriteValuedec64_OpLeq64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpLeq64U(v *Value, config *Config) bool { +func rewriteValuedec64_OpLeq64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Leq64U x y) // cond: // result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y)))) @@ -699,28 +755,28 @@ func rewriteValuedec64_OpLeq64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpOrB) - v0 := b.NewValue0(v.Pos, OpLess32U, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpLess32U, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpAndB, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v5 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) - v7 := b.NewValue0(v.Pos, OpLeq32U, config.fe.TypeBool()) - v8 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpLeq32U, fe.TypeBool()) + v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v8.AddArg(x) v7.AddArg(v8) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(y) v7.AddArg(v9) v3.AddArg(v7) @@ -728,9 +784,13 @@ func rewriteValuedec64_OpLeq64U(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpLess64(v *Value, config *Config) bool { +func rewriteValuedec64_OpLess64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less64 x y) // cond: // result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y)))) @@ -738,28 +798,28 @@ func rewriteValuedec64_OpLess64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpOrB) - v0 := b.NewValue0(v.Pos, OpLess32, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpLess32, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpAndB, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v5 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) - v7 := b.NewValue0(v.Pos, OpLess32U, config.fe.TypeBool()) - v8 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpLess32U, fe.TypeBool()) + v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v8.AddArg(x) v7.AddArg(v8) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(y) v7.AddArg(v9) v3.AddArg(v7) @@ -767,9 +827,13 @@ func rewriteValuedec64_OpLess64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpLess64U(v *Value, config *Config) bool { +func rewriteValuedec64_OpLess64U(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Less64U x y) // cond: // result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y)))) @@ -777,28 +841,28 @@ func rewriteValuedec64_OpLess64U(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpOrB) - v0 := b.NewValue0(v.Pos, OpLess32U, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpLess32U, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpAndB, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpEq32, config.fe.TypeBool()) - v5 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool()) + v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) - v7 := b.NewValue0(v.Pos, OpLess32U, config.fe.TypeBool()) - v8 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpLess32U, fe.TypeBool()) + v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v8.AddArg(x) v7.AddArg(v8) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(y) v7.AddArg(v9) v3.AddArg(v7) @@ -806,12 +870,16 @@ func rewriteValuedec64_OpLess64U(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpLoad(v *Value, config *Config) bool { +func rewriteValuedec64_OpLoad(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Load <t> ptr mem) // cond: is64BitInt(t) && !config.BigEndian && t.IsSigned() - // result: (Int64Make (Load <config.fe.TypeInt32()> (OffPtr <config.fe.TypeInt32().PtrTo()> [4] ptr) mem) (Load <config.fe.TypeUInt32()> ptr mem)) + // result: (Int64Make (Load <fe.TypeInt32()> (OffPtr <fe.TypeInt32().PtrTo()> [4] ptr) mem) (Load <fe.TypeUInt32()> ptr mem)) for { t := v.Type ptr := v.Args[0] @@ -820,14 +888,14 @@ func rewriteValuedec64_OpLoad(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeInt32()) - v1 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt32().PtrTo()) + v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt32().PtrTo()) v1.AuxInt = 4 v1.AddArg(ptr) v0.AddArg(v1) v0.AddArg(mem) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32()) v2.AddArg(ptr) v2.AddArg(mem) v.AddArg(v2) @@ -835,7 +903,7 @@ func rewriteValuedec64_OpLoad(v *Value, config *Config) bool { } // match: (Load <t> ptr mem) // cond: is64BitInt(t) && !config.BigEndian && !t.IsSigned() - // result: (Int64Make (Load <config.fe.TypeUInt32()> (OffPtr <config.fe.TypeUInt32().PtrTo()> [4] ptr) mem) (Load <config.fe.TypeUInt32()> ptr mem)) + // result: (Int64Make (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem) (Load <fe.TypeUInt32()> ptr mem)) for { t := v.Type ptr := v.Args[0] @@ -844,14 +912,14 @@ func rewriteValuedec64_OpLoad(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeUInt32().PtrTo()) + v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeUInt32().PtrTo()) v1.AuxInt = 4 v1.AddArg(ptr) v0.AddArg(v1) v0.AddArg(mem) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32()) v2.AddArg(ptr) v2.AddArg(mem) v.AddArg(v2) @@ -859,7 +927,7 @@ func rewriteValuedec64_OpLoad(v *Value, config *Config) bool { } // match: (Load <t> ptr mem) // cond: is64BitInt(t) && config.BigEndian && t.IsSigned() - // result: (Int64Make (Load <config.fe.TypeInt32()> ptr mem) (Load <config.fe.TypeUInt32()> (OffPtr <config.fe.TypeUInt32().PtrTo()> [4] ptr) mem)) + // result: (Int64Make (Load <fe.TypeInt32()> ptr mem) (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem)) for { t := v.Type ptr := v.Args[0] @@ -868,12 +936,12 @@ func rewriteValuedec64_OpLoad(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt32()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeUInt32().PtrTo()) + v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeUInt32().PtrTo()) v2.AuxInt = 4 v2.AddArg(ptr) v1.AddArg(v2) @@ -883,7 +951,7 @@ func rewriteValuedec64_OpLoad(v *Value, config *Config) bool { } // match: (Load <t> ptr mem) // cond: is64BitInt(t) && config.BigEndian && !t.IsSigned() - // result: (Int64Make (Load <config.fe.TypeUInt32()> ptr mem) (Load <config.fe.TypeUInt32()> (OffPtr <config.fe.TypeUInt32().PtrTo()> [4] ptr) mem)) + // result: (Int64Make (Load <fe.TypeUInt32()> ptr mem) (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem)) for { t := v.Type ptr := v.Args[0] @@ -892,12 +960,12 @@ func rewriteValuedec64_OpLoad(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpLoad, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeUInt32().PtrTo()) + v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeUInt32().PtrTo()) v2.AuxInt = 4 v2.AddArg(ptr) v1.AddArg(v2) @@ -907,9 +975,13 @@ func rewriteValuedec64_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpLsh16x64(v *Value, config *Config) bool { +func rewriteValuedec64_OpLsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x64 _ (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Const32 [0]) @@ -954,7 +1026,7 @@ func rewriteValuedec64_OpLsh16x64(v *Value, config *Config) bool { } // match: (Lsh16x64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Lsh16x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Lsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -968,8 +1040,8 @@ func rewriteValuedec64_OpLsh16x64(v *Value, config *Config) bool { } v.reset(OpLsh16x32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -978,9 +1050,13 @@ func rewriteValuedec64_OpLsh16x64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpLsh32x64(v *Value, config *Config) bool { +func rewriteValuedec64_OpLsh32x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x64 _ (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Const32 [0]) @@ -1025,7 +1101,7 @@ func rewriteValuedec64_OpLsh32x64(v *Value, config *Config) bool { } // match: (Lsh32x64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Lsh32x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Lsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -1039,8 +1115,8 @@ func rewriteValuedec64_OpLsh32x64(v *Value, config *Config) bool { } v.reset(OpLsh32x32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -1049,12 +1125,16 @@ func rewriteValuedec64_OpLsh32x64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpLsh64x16(v *Value, config *Config) bool { +func rewriteValuedec64_OpLsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x16 (Int64Make hi lo) s) // cond: - // result: (Int64Make (Or32 <config.fe.TypeUInt32()> (Or32 <config.fe.TypeUInt32()> (Lsh32x16 <config.fe.TypeUInt32()> hi s) (Rsh32Ux16 <config.fe.TypeUInt32()> lo (Sub16 <config.fe.TypeUInt16()> (Const16 <config.fe.TypeUInt16()> [32]) s))) (Lsh32x16 <config.fe.TypeUInt32()> lo (Sub16 <config.fe.TypeUInt16()> s (Const16 <config.fe.TypeUInt16()> [32])))) (Lsh32x16 <config.fe.TypeUInt32()> lo s)) + // result: (Int64Make (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Lsh32x16 <fe.TypeUInt32()> hi s) (Rsh32Ux16 <fe.TypeUInt32()> lo (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) (Lsh32x16 <fe.TypeUInt32()> lo (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32])))) (Lsh32x16 <fe.TypeUInt32()> lo s)) for { v_0 := v.Args[0] if v_0.Op != OpInt64Make { @@ -1064,33 +1144,33 @@ func rewriteValuedec64_OpLsh64x16(v *Value, config *Config) bool { lo := v_0.Args[1] s := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpLsh32x16, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32()) v2.AddArg(hi) v2.AddArg(s) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpRsh32Ux16, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32()) v3.AddArg(lo) - v4 := b.NewValue0(v.Pos, OpSub16, config.fe.TypeUInt16()) - v5 := b.NewValue0(v.Pos, OpConst16, config.fe.TypeUInt16()) + v4 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16()) + v5 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16()) v5.AuxInt = 32 v4.AddArg(v5) v4.AddArg(s) v3.AddArg(v4) v1.AddArg(v3) v0.AddArg(v1) - v6 := b.NewValue0(v.Pos, OpLsh32x16, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32()) v6.AddArg(lo) - v7 := b.NewValue0(v.Pos, OpSub16, config.fe.TypeUInt16()) + v7 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16()) v7.AddArg(s) - v8 := b.NewValue0(v.Pos, OpConst16, config.fe.TypeUInt16()) + v8 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16()) v8.AuxInt = 32 v7.AddArg(v8) v6.AddArg(v7) v0.AddArg(v6) v.AddArg(v0) - v9 := b.NewValue0(v.Pos, OpLsh32x16, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32()) v9.AddArg(lo) v9.AddArg(s) v.AddArg(v9) @@ -1098,12 +1178,16 @@ func rewriteValuedec64_OpLsh64x16(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpLsh64x32(v *Value, config *Config) bool { +func rewriteValuedec64_OpLsh64x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x32 (Int64Make hi lo) s) // cond: - // result: (Int64Make (Or32 <config.fe.TypeUInt32()> (Or32 <config.fe.TypeUInt32()> (Lsh32x32 <config.fe.TypeUInt32()> hi s) (Rsh32Ux32 <config.fe.TypeUInt32()> lo (Sub32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [32]) s))) (Lsh32x32 <config.fe.TypeUInt32()> lo (Sub32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [32])))) (Lsh32x32 <config.fe.TypeUInt32()> lo s)) + // result: (Int64Make (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Lsh32x32 <fe.TypeUInt32()> hi s) (Rsh32Ux32 <fe.TypeUInt32()> lo (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) (Lsh32x32 <fe.TypeUInt32()> lo (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32])))) (Lsh32x32 <fe.TypeUInt32()> lo s)) for { v_0 := v.Args[0] if v_0.Op != OpInt64Make { @@ -1113,33 +1197,33 @@ func rewriteValuedec64_OpLsh64x32(v *Value, config *Config) bool { lo := v_0.Args[1] s := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpLsh32x32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32()) v2.AddArg(hi) v2.AddArg(s) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpRsh32Ux32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32()) v3.AddArg(lo) - v4 := b.NewValue0(v.Pos, OpSub32, config.fe.TypeUInt32()) - v5 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v5.AuxInt = 32 v4.AddArg(v5) v4.AddArg(s) v3.AddArg(v4) v1.AddArg(v3) v0.AddArg(v1) - v6 := b.NewValue0(v.Pos, OpLsh32x32, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32()) v6.AddArg(lo) - v7 := b.NewValue0(v.Pos, OpSub32, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32()) v7.AddArg(s) - v8 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v8.AuxInt = 32 v7.AddArg(v8) v6.AddArg(v7) v0.AddArg(v6) v.AddArg(v0) - v9 := b.NewValue0(v.Pos, OpLsh32x32, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32()) v9.AddArg(lo) v9.AddArg(s) v.AddArg(v9) @@ -1147,9 +1231,13 @@ func rewriteValuedec64_OpLsh64x32(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpLsh64x64(v *Value, config *Config) bool { +func rewriteValuedec64_OpLsh64x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x64 _ (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Const64 [0]) @@ -1194,7 +1282,7 @@ func rewriteValuedec64_OpLsh64x64(v *Value, config *Config) bool { } // match: (Lsh64x64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Lsh64x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Lsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -1208,8 +1296,8 @@ func rewriteValuedec64_OpLsh64x64(v *Value, config *Config) bool { } v.reset(OpLsh64x32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -1218,12 +1306,16 @@ func rewriteValuedec64_OpLsh64x64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpLsh64x8(v *Value, config *Config) bool { +func rewriteValuedec64_OpLsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x8 (Int64Make hi lo) s) // cond: - // result: (Int64Make (Or32 <config.fe.TypeUInt32()> (Or32 <config.fe.TypeUInt32()> (Lsh32x8 <config.fe.TypeUInt32()> hi s) (Rsh32Ux8 <config.fe.TypeUInt32()> lo (Sub8 <config.fe.TypeUInt8()> (Const8 <config.fe.TypeUInt8()> [32]) s))) (Lsh32x8 <config.fe.TypeUInt32()> lo (Sub8 <config.fe.TypeUInt8()> s (Const8 <config.fe.TypeUInt8()> [32])))) (Lsh32x8 <config.fe.TypeUInt32()> lo s)) + // result: (Int64Make (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Lsh32x8 <fe.TypeUInt32()> hi s) (Rsh32Ux8 <fe.TypeUInt32()> lo (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) (Lsh32x8 <fe.TypeUInt32()> lo (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32])))) (Lsh32x8 <fe.TypeUInt32()> lo s)) for { v_0 := v.Args[0] if v_0.Op != OpInt64Make { @@ -1233,33 +1325,33 @@ func rewriteValuedec64_OpLsh64x8(v *Value, config *Config) bool { lo := v_0.Args[1] s := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpLsh32x8, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32()) v2.AddArg(hi) v2.AddArg(s) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpRsh32Ux8, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32()) v3.AddArg(lo) - v4 := b.NewValue0(v.Pos, OpSub8, config.fe.TypeUInt8()) - v5 := b.NewValue0(v.Pos, OpConst8, config.fe.TypeUInt8()) + v4 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8()) + v5 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8()) v5.AuxInt = 32 v4.AddArg(v5) v4.AddArg(s) v3.AddArg(v4) v1.AddArg(v3) v0.AddArg(v1) - v6 := b.NewValue0(v.Pos, OpLsh32x8, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32()) v6.AddArg(lo) - v7 := b.NewValue0(v.Pos, OpSub8, config.fe.TypeUInt8()) + v7 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8()) v7.AddArg(s) - v8 := b.NewValue0(v.Pos, OpConst8, config.fe.TypeUInt8()) + v8 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8()) v8.AuxInt = 32 v7.AddArg(v8) v6.AddArg(v7) v0.AddArg(v6) v.AddArg(v0) - v9 := b.NewValue0(v.Pos, OpLsh32x8, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32()) v9.AddArg(lo) v9.AddArg(s) v.AddArg(v9) @@ -1267,9 +1359,13 @@ func rewriteValuedec64_OpLsh64x8(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpLsh8x64(v *Value, config *Config) bool { +func rewriteValuedec64_OpLsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x64 _ (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Const32 [0]) @@ -1314,7 +1410,7 @@ func rewriteValuedec64_OpLsh8x64(v *Value, config *Config) bool { } // match: (Lsh8x64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Lsh8x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Lsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -1328,8 +1424,8 @@ func rewriteValuedec64_OpLsh8x64(v *Value, config *Config) bool { } v.reset(OpLsh8x32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -1338,52 +1434,56 @@ func rewriteValuedec64_OpLsh8x64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpMul64(v *Value, config *Config) bool { +func rewriteValuedec64_OpMul64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mul64 x y) // cond: - // result: (Int64Make (Add32 <config.fe.TypeUInt32()> (Mul32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Hi y)) (Add32 <config.fe.TypeUInt32()> (Mul32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Lo y)) (Select0 <config.fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) (Select1 <config.fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y)))) + // result: (Int64Make (Add32 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Int64Lo x) (Int64Hi y)) (Add32 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Int64Hi x) (Int64Lo y)) (Select0 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) (Select1 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpAdd32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpMul32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpAdd32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v2.AddArg(x) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v3.AddArg(y) v1.AddArg(v3) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpAdd32, config.fe.TypeUInt32()) - v5 := b.NewValue0(v.Pos, OpMul32, config.fe.TypeUInt32()) - v6 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpAdd32, fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v6.AddArg(x) v5.AddArg(v6) - v7 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v7.AddArg(y) v5.AddArg(v7) v4.AddArg(v5) - v8 := b.NewValue0(v.Pos, OpSelect0, config.fe.TypeUInt32()) - v9 := b.NewValue0(v.Pos, OpMul32uhilo, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) - v10 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpSelect0, fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpMul32uhilo, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) + v10 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v10.AddArg(x) v9.AddArg(v10) - v11 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v11 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v11.AddArg(y) v9.AddArg(v11) v8.AddArg(v9) v4.AddArg(v8) v0.AddArg(v4) v.AddArg(v0) - v12 := b.NewValue0(v.Pos, OpSelect1, config.fe.TypeUInt32()) - v13 := b.NewValue0(v.Pos, OpMul32uhilo, MakeTuple(config.fe.TypeUInt32(), config.fe.TypeUInt32())) - v14 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v12 := b.NewValue0(v.Pos, OpSelect1, fe.TypeUInt32()) + v13 := b.NewValue0(v.Pos, OpMul32uhilo, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) + v14 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v14.AddArg(x) v13.AddArg(v14) - v15 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v15 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v15.AddArg(y) v13.AddArg(v15) v12.AddArg(v13) @@ -1391,7 +1491,7 @@ func rewriteValuedec64_OpMul64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpNeg64(v *Value, config *Config) bool { +func rewriteValuedec64_OpNeg64(v *Value) bool { b := v.Block _ = b // match: (Neg64 <t> x) @@ -1408,9 +1508,13 @@ func rewriteValuedec64_OpNeg64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpNeq64(v *Value, config *Config) bool { +func rewriteValuedec64_OpNeq64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Neq64 x y) // cond: // result: (OrB (Neq32 (Int64Hi x) (Int64Hi y)) (Neq32 (Int64Lo x) (Int64Lo y))) @@ -1418,57 +1522,65 @@ func rewriteValuedec64_OpNeq64(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpOrB) - v0 := b.NewValue0(v.Pos, OpNeq32, config.fe.TypeBool()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpNeq32, fe.TypeBool()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpNeq32, config.fe.TypeBool()) - v4 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpNeq32, fe.TypeBool()) + v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v4.AddArg(x) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v5.AddArg(y) v3.AddArg(v5) v.AddArg(v3) return true } } -func rewriteValuedec64_OpOr64(v *Value, config *Config) bool { +func rewriteValuedec64_OpOr64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Or64 x y) // cond: - // result: (Int64Make (Or32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (Or32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) + // result: (Int64Make (Or32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (Or32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) for { x := v.Args[0] y := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v4.AddArg(x) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v5.AddArg(y) v3.AddArg(v5) v.AddArg(v3) return true } } -func rewriteValuedec64_OpRsh16Ux64(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh16Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux64 _ (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Const32 [0]) @@ -1513,7 +1625,7 @@ func rewriteValuedec64_OpRsh16Ux64(v *Value, config *Config) bool { } // match: (Rsh16Ux64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Rsh16Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Rsh16Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -1527,8 +1639,8 @@ func rewriteValuedec64_OpRsh16Ux64(v *Value, config *Config) bool { } v.reset(OpRsh16Ux32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -1537,9 +1649,13 @@ func rewriteValuedec64_OpRsh16Ux64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh16x64(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x64 x (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Signmask (SignExt16to32 x)) @@ -1558,7 +1674,7 @@ func rewriteValuedec64_OpRsh16x64(v *Value, config *Config) bool { break } v.reset(OpSignmask) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -1587,7 +1703,7 @@ func rewriteValuedec64_OpRsh16x64(v *Value, config *Config) bool { } // match: (Rsh16x64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Rsh16x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Rsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -1601,8 +1717,8 @@ func rewriteValuedec64_OpRsh16x64(v *Value, config *Config) bool { } v.reset(OpRsh16x32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -1611,9 +1727,13 @@ func rewriteValuedec64_OpRsh16x64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh32Ux64(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh32Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux64 _ (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Const32 [0]) @@ -1658,7 +1778,7 @@ func rewriteValuedec64_OpRsh32Ux64(v *Value, config *Config) bool { } // match: (Rsh32Ux64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Rsh32Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Rsh32Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -1672,8 +1792,8 @@ func rewriteValuedec64_OpRsh32Ux64(v *Value, config *Config) bool { } v.reset(OpRsh32Ux32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -1682,9 +1802,13 @@ func rewriteValuedec64_OpRsh32Ux64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh32x64(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh32x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x64 x (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Signmask x) @@ -1730,7 +1854,7 @@ func rewriteValuedec64_OpRsh32x64(v *Value, config *Config) bool { } // match: (Rsh32x64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Rsh32x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Rsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -1744,8 +1868,8 @@ func rewriteValuedec64_OpRsh32x64(v *Value, config *Config) bool { } v.reset(OpRsh32x32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -1754,12 +1878,16 @@ func rewriteValuedec64_OpRsh32x64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh64Ux16(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh64Ux16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux16 (Int64Make hi lo) s) // cond: - // result: (Int64Make (Rsh32Ux16 <config.fe.TypeUInt32()> hi s) (Or32 <config.fe.TypeUInt32()> (Or32 <config.fe.TypeUInt32()> (Rsh32Ux16 <config.fe.TypeUInt32()> lo s) (Lsh32x16 <config.fe.TypeUInt32()> hi (Sub16 <config.fe.TypeUInt16()> (Const16 <config.fe.TypeUInt16()> [32]) s))) (Rsh32Ux16 <config.fe.TypeUInt32()> hi (Sub16 <config.fe.TypeUInt16()> s (Const16 <config.fe.TypeUInt16()> [32]))))) + // result: (Int64Make (Rsh32Ux16 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux16 <fe.TypeUInt32()> lo s) (Lsh32x16 <fe.TypeUInt32()> hi (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) (Rsh32Ux16 <fe.TypeUInt32()> hi (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32]))))) for { v_0 := v.Args[0] if v_0.Op != OpInt64Make { @@ -1769,31 +1897,31 @@ func rewriteValuedec64_OpRsh64Ux16(v *Value, config *Config) bool { lo := v_0.Args[1] s := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpRsh32Ux16, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32()) v0.AddArg(hi) v0.AddArg(s) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpRsh32Ux16, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32()) v3.AddArg(lo) v3.AddArg(s) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpLsh32x16, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32()) v4.AddArg(hi) - v5 := b.NewValue0(v.Pos, OpSub16, config.fe.TypeUInt16()) - v6 := b.NewValue0(v.Pos, OpConst16, config.fe.TypeUInt16()) + v5 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16()) + v6 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16()) v6.AuxInt = 32 v5.AddArg(v6) v5.AddArg(s) v4.AddArg(v5) v2.AddArg(v4) v1.AddArg(v2) - v7 := b.NewValue0(v.Pos, OpRsh32Ux16, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32()) v7.AddArg(hi) - v8 := b.NewValue0(v.Pos, OpSub16, config.fe.TypeUInt16()) + v8 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16()) v8.AddArg(s) - v9 := b.NewValue0(v.Pos, OpConst16, config.fe.TypeUInt16()) + v9 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16()) v9.AuxInt = 32 v8.AddArg(v9) v7.AddArg(v8) @@ -1803,12 +1931,16 @@ func rewriteValuedec64_OpRsh64Ux16(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh64Ux32(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh64Ux32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux32 (Int64Make hi lo) s) // cond: - // result: (Int64Make (Rsh32Ux32 <config.fe.TypeUInt32()> hi s) (Or32 <config.fe.TypeUInt32()> (Or32 <config.fe.TypeUInt32()> (Rsh32Ux32 <config.fe.TypeUInt32()> lo s) (Lsh32x32 <config.fe.TypeUInt32()> hi (Sub32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [32]) s))) (Rsh32Ux32 <config.fe.TypeUInt32()> hi (Sub32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [32]))))) + // result: (Int64Make (Rsh32Ux32 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux32 <fe.TypeUInt32()> lo s) (Lsh32x32 <fe.TypeUInt32()> hi (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) (Rsh32Ux32 <fe.TypeUInt32()> hi (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32]))))) for { v_0 := v.Args[0] if v_0.Op != OpInt64Make { @@ -1818,31 +1950,31 @@ func rewriteValuedec64_OpRsh64Ux32(v *Value, config *Config) bool { lo := v_0.Args[1] s := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpRsh32Ux32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32()) v0.AddArg(hi) v0.AddArg(s) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpRsh32Ux32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32()) v3.AddArg(lo) v3.AddArg(s) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpLsh32x32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32()) v4.AddArg(hi) - v5 := b.NewValue0(v.Pos, OpSub32, config.fe.TypeUInt32()) - v6 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v6.AuxInt = 32 v5.AddArg(v6) v5.AddArg(s) v4.AddArg(v5) v2.AddArg(v4) v1.AddArg(v2) - v7 := b.NewValue0(v.Pos, OpRsh32Ux32, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32()) v7.AddArg(hi) - v8 := b.NewValue0(v.Pos, OpSub32, config.fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32()) v8.AddArg(s) - v9 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v9.AuxInt = 32 v8.AddArg(v9) v7.AddArg(v8) @@ -1852,9 +1984,13 @@ func rewriteValuedec64_OpRsh64Ux32(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh64Ux64(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh64Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux64 _ (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Const64 [0]) @@ -1899,7 +2035,7 @@ func rewriteValuedec64_OpRsh64Ux64(v *Value, config *Config) bool { } // match: (Rsh64Ux64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Rsh64Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Rsh64Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -1913,8 +2049,8 @@ func rewriteValuedec64_OpRsh64Ux64(v *Value, config *Config) bool { } v.reset(OpRsh64Ux32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -1923,12 +2059,16 @@ func rewriteValuedec64_OpRsh64Ux64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh64Ux8(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh64Ux8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux8 (Int64Make hi lo) s) // cond: - // result: (Int64Make (Rsh32Ux8 <config.fe.TypeUInt32()> hi s) (Or32 <config.fe.TypeUInt32()> (Or32 <config.fe.TypeUInt32()> (Rsh32Ux8 <config.fe.TypeUInt32()> lo s) (Lsh32x8 <config.fe.TypeUInt32()> hi (Sub8 <config.fe.TypeUInt8()> (Const8 <config.fe.TypeUInt8()> [32]) s))) (Rsh32Ux8 <config.fe.TypeUInt32()> hi (Sub8 <config.fe.TypeUInt8()> s (Const8 <config.fe.TypeUInt8()> [32]))))) + // result: (Int64Make (Rsh32Ux8 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux8 <fe.TypeUInt32()> lo s) (Lsh32x8 <fe.TypeUInt32()> hi (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) (Rsh32Ux8 <fe.TypeUInt32()> hi (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32]))))) for { v_0 := v.Args[0] if v_0.Op != OpInt64Make { @@ -1938,31 +2078,31 @@ func rewriteValuedec64_OpRsh64Ux8(v *Value, config *Config) bool { lo := v_0.Args[1] s := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpRsh32Ux8, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32()) v0.AddArg(hi) v0.AddArg(s) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpRsh32Ux8, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32()) v3.AddArg(lo) v3.AddArg(s) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpLsh32x8, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32()) v4.AddArg(hi) - v5 := b.NewValue0(v.Pos, OpSub8, config.fe.TypeUInt8()) - v6 := b.NewValue0(v.Pos, OpConst8, config.fe.TypeUInt8()) + v5 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8()) + v6 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8()) v6.AuxInt = 32 v5.AddArg(v6) v5.AddArg(s) v4.AddArg(v5) v2.AddArg(v4) v1.AddArg(v2) - v7 := b.NewValue0(v.Pos, OpRsh32Ux8, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32()) v7.AddArg(hi) - v8 := b.NewValue0(v.Pos, OpSub8, config.fe.TypeUInt8()) + v8 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8()) v8.AddArg(s) - v9 := b.NewValue0(v.Pos, OpConst8, config.fe.TypeUInt8()) + v9 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8()) v9.AuxInt = 32 v8.AddArg(v9) v7.AddArg(v8) @@ -1972,12 +2112,16 @@ func rewriteValuedec64_OpRsh64Ux8(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh64x16(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh64x16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x16 (Int64Make hi lo) s) // cond: - // result: (Int64Make (Rsh32x16 <config.fe.TypeUInt32()> hi s) (Or32 <config.fe.TypeUInt32()> (Or32 <config.fe.TypeUInt32()> (Rsh32Ux16 <config.fe.TypeUInt32()> lo s) (Lsh32x16 <config.fe.TypeUInt32()> hi (Sub16 <config.fe.TypeUInt16()> (Const16 <config.fe.TypeUInt16()> [32]) s))) (And32 <config.fe.TypeUInt32()> (Rsh32x16 <config.fe.TypeUInt32()> hi (Sub16 <config.fe.TypeUInt16()> s (Const16 <config.fe.TypeUInt16()> [32]))) (Zeromask (ZeroExt16to32 (Rsh16Ux32 <config.fe.TypeUInt16()> s (Const32 <config.fe.TypeUInt32()> [5]))))))) + // result: (Int64Make (Rsh32x16 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux16 <fe.TypeUInt32()> lo s) (Lsh32x16 <fe.TypeUInt32()> hi (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) (And32 <fe.TypeUInt32()> (Rsh32x16 <fe.TypeUInt32()> hi (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32]))) (Zeromask (ZeroExt16to32 (Rsh16Ux32 <fe.TypeUInt16()> s (Const32 <fe.TypeUInt32()> [5]))))))) for { v_0 := v.Args[0] if v_0.Op != OpInt64Make { @@ -1987,41 +2131,41 @@ func rewriteValuedec64_OpRsh64x16(v *Value, config *Config) bool { lo := v_0.Args[1] s := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpRsh32x16, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32x16, fe.TypeUInt32()) v0.AddArg(hi) v0.AddArg(s) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpRsh32Ux16, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32()) v3.AddArg(lo) v3.AddArg(s) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpLsh32x16, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32()) v4.AddArg(hi) - v5 := b.NewValue0(v.Pos, OpSub16, config.fe.TypeUInt16()) - v6 := b.NewValue0(v.Pos, OpConst16, config.fe.TypeUInt16()) + v5 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16()) + v6 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16()) v6.AuxInt = 32 v5.AddArg(v6) v5.AddArg(s) v4.AddArg(v5) v2.AddArg(v4) v1.AddArg(v2) - v7 := b.NewValue0(v.Pos, OpAnd32, config.fe.TypeUInt32()) - v8 := b.NewValue0(v.Pos, OpRsh32x16, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpRsh32x16, fe.TypeUInt32()) v8.AddArg(hi) - v9 := b.NewValue0(v.Pos, OpSub16, config.fe.TypeUInt16()) + v9 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16()) v9.AddArg(s) - v10 := b.NewValue0(v.Pos, OpConst16, config.fe.TypeUInt16()) + v10 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16()) v10.AuxInt = 32 v9.AddArg(v10) v8.AddArg(v9) v7.AddArg(v8) - v11 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) - v12 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) - v13 := b.NewValue0(v.Pos, OpRsh16Ux32, config.fe.TypeUInt16()) + v11 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) + v12 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) + v13 := b.NewValue0(v.Pos, OpRsh16Ux32, fe.TypeUInt16()) v13.AddArg(s) - v14 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v14 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v14.AuxInt = 5 v13.AddArg(v14) v12.AddArg(v13) @@ -2033,12 +2177,16 @@ func rewriteValuedec64_OpRsh64x16(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh64x32(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh64x32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x32 (Int64Make hi lo) s) // cond: - // result: (Int64Make (Rsh32x32 <config.fe.TypeUInt32()> hi s) (Or32 <config.fe.TypeUInt32()> (Or32 <config.fe.TypeUInt32()> (Rsh32Ux32 <config.fe.TypeUInt32()> lo s) (Lsh32x32 <config.fe.TypeUInt32()> hi (Sub32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [32]) s))) (And32 <config.fe.TypeUInt32()> (Rsh32x32 <config.fe.TypeUInt32()> hi (Sub32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [32]))) (Zeromask (Rsh32Ux32 <config.fe.TypeUInt32()> s (Const32 <config.fe.TypeUInt32()> [5])))))) + // result: (Int64Make (Rsh32x32 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux32 <fe.TypeUInt32()> lo s) (Lsh32x32 <fe.TypeUInt32()> hi (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) (And32 <fe.TypeUInt32()> (Rsh32x32 <fe.TypeUInt32()> hi (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32]))) (Zeromask (Rsh32Ux32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [5])))))) for { v_0 := v.Args[0] if v_0.Op != OpInt64Make { @@ -2048,40 +2196,40 @@ func rewriteValuedec64_OpRsh64x32(v *Value, config *Config) bool { lo := v_0.Args[1] s := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpRsh32x32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32x32, fe.TypeUInt32()) v0.AddArg(hi) v0.AddArg(s) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpRsh32Ux32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32()) v3.AddArg(lo) v3.AddArg(s) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpLsh32x32, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32()) v4.AddArg(hi) - v5 := b.NewValue0(v.Pos, OpSub32, config.fe.TypeUInt32()) - v6 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v6.AuxInt = 32 v5.AddArg(v6) v5.AddArg(s) v4.AddArg(v5) v2.AddArg(v4) v1.AddArg(v2) - v7 := b.NewValue0(v.Pos, OpAnd32, config.fe.TypeUInt32()) - v8 := b.NewValue0(v.Pos, OpRsh32x32, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpRsh32x32, fe.TypeUInt32()) v8.AddArg(hi) - v9 := b.NewValue0(v.Pos, OpSub32, config.fe.TypeUInt32()) + v9 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32()) v9.AddArg(s) - v10 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v10 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v10.AuxInt = 32 v9.AddArg(v10) v8.AddArg(v9) v7.AddArg(v8) - v11 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) - v12 := b.NewValue0(v.Pos, OpRsh32Ux32, config.fe.TypeUInt32()) + v11 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) + v12 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32()) v12.AddArg(s) - v13 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v13 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v13.AuxInt = 5 v12.AddArg(v13) v11.AddArg(v12) @@ -2092,9 +2240,13 @@ func rewriteValuedec64_OpRsh64x32(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh64x64(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh64x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x64 x (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Int64Make (Signmask (Int64Hi x)) (Signmask (Int64Hi x))) @@ -2113,13 +2265,13 @@ func rewriteValuedec64_OpRsh64x64(v *Value, config *Config) bool { break } v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) - v3 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) + v3 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v3.AddArg(x) v2.AddArg(v3) v.AddArg(v2) @@ -2149,7 +2301,7 @@ func rewriteValuedec64_OpRsh64x64(v *Value, config *Config) bool { } // match: (Rsh64x64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Rsh64x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Rsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -2163,8 +2315,8 @@ func rewriteValuedec64_OpRsh64x64(v *Value, config *Config) bool { } v.reset(OpRsh64x32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -2173,12 +2325,16 @@ func rewriteValuedec64_OpRsh64x64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh64x8(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh64x8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x8 (Int64Make hi lo) s) // cond: - // result: (Int64Make (Rsh32x8 <config.fe.TypeUInt32()> hi s) (Or32 <config.fe.TypeUInt32()> (Or32 <config.fe.TypeUInt32()> (Rsh32Ux8 <config.fe.TypeUInt32()> lo s) (Lsh32x8 <config.fe.TypeUInt32()> hi (Sub8 <config.fe.TypeUInt8()> (Const8 <config.fe.TypeUInt8()> [32]) s))) (And32 <config.fe.TypeUInt32()> (Rsh32x8 <config.fe.TypeUInt32()> hi (Sub8 <config.fe.TypeUInt8()> s (Const8 <config.fe.TypeUInt8()> [32]))) (Zeromask (ZeroExt8to32 (Rsh8Ux32 <config.fe.TypeUInt8()> s (Const32 <config.fe.TypeUInt32()> [5]))))))) + // result: (Int64Make (Rsh32x8 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux8 <fe.TypeUInt32()> lo s) (Lsh32x8 <fe.TypeUInt32()> hi (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) (And32 <fe.TypeUInt32()> (Rsh32x8 <fe.TypeUInt32()> hi (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32]))) (Zeromask (ZeroExt8to32 (Rsh8Ux32 <fe.TypeUInt8()> s (Const32 <fe.TypeUInt32()> [5]))))))) for { v_0 := v.Args[0] if v_0.Op != OpInt64Make { @@ -2188,41 +2344,41 @@ func rewriteValuedec64_OpRsh64x8(v *Value, config *Config) bool { lo := v_0.Args[1] s := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpRsh32x8, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32x8, fe.TypeUInt32()) v0.AddArg(hi) v0.AddArg(s) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpRsh32Ux8, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32()) v3.AddArg(lo) v3.AddArg(s) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpLsh32x8, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32()) v4.AddArg(hi) - v5 := b.NewValue0(v.Pos, OpSub8, config.fe.TypeUInt8()) - v6 := b.NewValue0(v.Pos, OpConst8, config.fe.TypeUInt8()) + v5 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8()) + v6 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8()) v6.AuxInt = 32 v5.AddArg(v6) v5.AddArg(s) v4.AddArg(v5) v2.AddArg(v4) v1.AddArg(v2) - v7 := b.NewValue0(v.Pos, OpAnd32, config.fe.TypeUInt32()) - v8 := b.NewValue0(v.Pos, OpRsh32x8, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpRsh32x8, fe.TypeUInt32()) v8.AddArg(hi) - v9 := b.NewValue0(v.Pos, OpSub8, config.fe.TypeUInt8()) + v9 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8()) v9.AddArg(s) - v10 := b.NewValue0(v.Pos, OpConst8, config.fe.TypeUInt8()) + v10 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8()) v10.AuxInt = 32 v9.AddArg(v10) v8.AddArg(v9) v7.AddArg(v8) - v11 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) - v12 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) - v13 := b.NewValue0(v.Pos, OpRsh8Ux32, config.fe.TypeUInt8()) + v11 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) + v12 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) + v13 := b.NewValue0(v.Pos, OpRsh8Ux32, fe.TypeUInt8()) v13.AddArg(s) - v14 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v14 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v14.AuxInt = 5 v13.AddArg(v14) v12.AddArg(v13) @@ -2234,9 +2390,13 @@ func rewriteValuedec64_OpRsh64x8(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh8Ux64(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh8Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux64 _ (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Const32 [0]) @@ -2281,7 +2441,7 @@ func rewriteValuedec64_OpRsh8Ux64(v *Value, config *Config) bool { } // match: (Rsh8Ux64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Rsh8Ux32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Rsh8Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -2295,8 +2455,8 @@ func rewriteValuedec64_OpRsh8Ux64(v *Value, config *Config) bool { } v.reset(OpRsh8Ux32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -2305,9 +2465,13 @@ func rewriteValuedec64_OpRsh8Ux64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpRsh8x64(v *Value, config *Config) bool { +func rewriteValuedec64_OpRsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8x64 x (Int64Make (Const32 [c]) _)) // cond: c != 0 // result: (Signmask (SignExt8to32 x)) @@ -2326,7 +2490,7 @@ func rewriteValuedec64_OpRsh8x64(v *Value, config *Config) bool { break } v.reset(OpSignmask) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true @@ -2355,7 +2519,7 @@ func rewriteValuedec64_OpRsh8x64(v *Value, config *Config) bool { } // match: (Rsh8x64 x (Int64Make hi lo)) // cond: hi.Op != OpConst32 - // result: (Rsh8x32 x (Or32 <config.fe.TypeUInt32()> (Zeromask hi) lo)) + // result: (Rsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) for { x := v.Args[0] v_1 := v.Args[1] @@ -2369,8 +2533,8 @@ func rewriteValuedec64_OpRsh8x64(v *Value, config *Config) bool { } v.reset(OpRsh8x32) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpOr32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpZeromask, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32()) v1.AddArg(hi) v0.AddArg(v1) v0.AddArg(lo) @@ -2379,55 +2543,69 @@ func rewriteValuedec64_OpRsh8x64(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpSignExt16to64(v *Value, config *Config) bool { +func rewriteValuedec64_OpSignExt16to64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (SignExt16to64 x) // cond: // result: (SignExt32to64 (SignExt16to32 x)) for { x := v.Args[0] v.reset(OpSignExt32to64) - v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValuedec64_OpSignExt32to64(v *Value, config *Config) bool { +func rewriteValuedec64_OpSignExt32to64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (SignExt32to64 x) // cond: // result: (Int64Make (Signmask x) x) for { x := v.Args[0] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpSignmask, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) v.AddArg(x) return true } } -func rewriteValuedec64_OpSignExt8to64(v *Value, config *Config) bool { +func rewriteValuedec64_OpSignExt8to64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (SignExt8to64 x) // cond: // result: (SignExt32to64 (SignExt8to32 x)) for { x := v.Args[0] v.reset(OpSignExt32to64) - v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValuedec64_OpStore(v *Value, config *Config) bool { +func rewriteValuedec64_OpStore(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (Store {t} dst (Int64Make hi lo) mem) // cond: t.(Type).Size() == 8 && !config.BigEndian // result: (Store {hi.Type} (OffPtr <hi.Type.PtrTo()> [4] dst) hi (Store {lo.Type} dst lo mem)) @@ -2492,40 +2670,44 @@ func rewriteValuedec64_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpSub64(v *Value, config *Config) bool { +func rewriteValuedec64_OpSub64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Sub64 x y) // cond: - // result: (Int64Make (Sub32withcarry <config.fe.TypeInt32()> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y)))) (Select0 <config.fe.TypeUInt32()> (Sub32carry (Int64Lo x) (Int64Lo y)))) + // result: (Int64Make (Sub32withcarry <fe.TypeInt32()> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y)))) (Select0 <fe.TypeUInt32()> (Sub32carry (Int64Lo x) (Int64Lo y)))) for { x := v.Args[0] y := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpSub32withcarry, config.fe.TypeInt32()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpSub32withcarry, fe.TypeInt32()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v3 := b.NewValue0(v.Pos, OpSelect1, TypeFlags) - v4 := b.NewValue0(v.Pos, OpSub32carry, MakeTuple(config.fe.TypeUInt32(), TypeFlags)) - v5 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpSub32carry, MakeTuple(fe.TypeUInt32(), TypeFlags)) + v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v5.AddArg(x) v4.AddArg(v5) - v6 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v6.AddArg(y) v4.AddArg(v6) v3.AddArg(v4) v0.AddArg(v3) v.AddArg(v0) - v7 := b.NewValue0(v.Pos, OpSelect0, config.fe.TypeUInt32()) - v8 := b.NewValue0(v.Pos, OpSub32carry, MakeTuple(config.fe.TypeUInt32(), TypeFlags)) - v9 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpSelect0, fe.TypeUInt32()) + v8 := b.NewValue0(v.Pos, OpSub32carry, MakeTuple(fe.TypeUInt32(), TypeFlags)) + v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v9.AddArg(x) v8.AddArg(v9) - v10 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v10 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v10.AddArg(y) v8.AddArg(v10) v7.AddArg(v8) @@ -2533,9 +2715,7 @@ func rewriteValuedec64_OpSub64(v *Value, config *Config) bool { return true } } -func rewriteValuedec64_OpTrunc64to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec64_OpTrunc64to16(v *Value) bool { // match: (Trunc64to16 (Int64Make _ lo)) // cond: // result: (Trunc32to16 lo) @@ -2551,9 +2731,7 @@ func rewriteValuedec64_OpTrunc64to16(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpTrunc64to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec64_OpTrunc64to32(v *Value) bool { // match: (Trunc64to32 (Int64Make _ lo)) // cond: // result: lo @@ -2570,9 +2748,7 @@ func rewriteValuedec64_OpTrunc64to32(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpTrunc64to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuedec64_OpTrunc64to8(v *Value) bool { // match: (Trunc64to8 (Int64Make _ lo)) // cond: // result: (Trunc32to8 lo) @@ -2588,82 +2764,102 @@ func rewriteValuedec64_OpTrunc64to8(v *Value, config *Config) bool { } return false } -func rewriteValuedec64_OpXor64(v *Value, config *Config) bool { +func rewriteValuedec64_OpXor64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Xor64 x y) // cond: - // result: (Int64Make (Xor32 <config.fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (Xor32 <config.fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) + // result: (Int64Make (Xor32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (Xor32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) for { x := v.Args[0] y := v.Args[1] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpXor32, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpXor32, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v1.AddArg(x) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpInt64Hi, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32()) v2.AddArg(y) v0.AddArg(v2) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpXor32, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpXor32, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v4.AddArg(x) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpInt64Lo, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32()) v5.AddArg(y) v3.AddArg(v5) v.AddArg(v3) return true } } -func rewriteValuedec64_OpZeroExt16to64(v *Value, config *Config) bool { +func rewriteValuedec64_OpZeroExt16to64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ZeroExt16to64 x) // cond: // result: (ZeroExt32to64 (ZeroExt16to32 x)) for { x := v.Args[0] v.reset(OpZeroExt32to64) - v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteValuedec64_OpZeroExt32to64(v *Value, config *Config) bool { +func rewriteValuedec64_OpZeroExt32to64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ZeroExt32to64 x) // cond: - // result: (Int64Make (Const32 <config.fe.TypeUInt32()> [0]) x) + // result: (Int64Make (Const32 <fe.TypeUInt32()> [0]) x) for { x := v.Args[0] v.reset(OpInt64Make) - v0 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v0.AuxInt = 0 v.AddArg(v0) v.AddArg(x) return true } } -func rewriteValuedec64_OpZeroExt8to64(v *Value, config *Config) bool { +func rewriteValuedec64_OpZeroExt8to64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ZeroExt8to64 x) // cond: // result: (ZeroExt32to64 (ZeroExt8to32 x)) for { x := v.Args[0] v.reset(OpZeroExt32to64) - v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true } } -func rewriteBlockdec64(b *Block, config *Config) bool { +func rewriteBlockdec64(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { } return false diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 73dccf21d3..edabce6699 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -6,420 +6,420 @@ package ssa import "math" var _ = math.MinInt8 // in case not otherwise used -func rewriteValuegeneric(v *Value, config *Config) bool { +func rewriteValuegeneric(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValuegeneric_OpAdd16(v, config) + return rewriteValuegeneric_OpAdd16(v) case OpAdd32: - return rewriteValuegeneric_OpAdd32(v, config) + return rewriteValuegeneric_OpAdd32(v) case OpAdd32F: - return rewriteValuegeneric_OpAdd32F(v, config) + return rewriteValuegeneric_OpAdd32F(v) case OpAdd64: - return rewriteValuegeneric_OpAdd64(v, config) + return rewriteValuegeneric_OpAdd64(v) case OpAdd64F: - return rewriteValuegeneric_OpAdd64F(v, config) + return rewriteValuegeneric_OpAdd64F(v) case OpAdd8: - return rewriteValuegeneric_OpAdd8(v, config) + return rewriteValuegeneric_OpAdd8(v) case OpAddPtr: - return rewriteValuegeneric_OpAddPtr(v, config) + return rewriteValuegeneric_OpAddPtr(v) case OpAnd16: - return rewriteValuegeneric_OpAnd16(v, config) + return rewriteValuegeneric_OpAnd16(v) case OpAnd32: - return rewriteValuegeneric_OpAnd32(v, config) + return rewriteValuegeneric_OpAnd32(v) case OpAnd64: - return rewriteValuegeneric_OpAnd64(v, config) + return rewriteValuegeneric_OpAnd64(v) case OpAnd8: - return rewriteValuegeneric_OpAnd8(v, config) + return rewriteValuegeneric_OpAnd8(v) case OpArg: - return rewriteValuegeneric_OpArg(v, config) + return rewriteValuegeneric_OpArg(v) case OpArraySelect: - return rewriteValuegeneric_OpArraySelect(v, config) + return rewriteValuegeneric_OpArraySelect(v) case OpCom16: - return rewriteValuegeneric_OpCom16(v, config) + return rewriteValuegeneric_OpCom16(v) case OpCom32: - return rewriteValuegeneric_OpCom32(v, config) + return rewriteValuegeneric_OpCom32(v) case OpCom64: - return rewriteValuegeneric_OpCom64(v, config) + return rewriteValuegeneric_OpCom64(v) case OpCom8: - return rewriteValuegeneric_OpCom8(v, config) + return rewriteValuegeneric_OpCom8(v) case OpConstInterface: - return rewriteValuegeneric_OpConstInterface(v, config) + return rewriteValuegeneric_OpConstInterface(v) case OpConstSlice: - return rewriteValuegeneric_OpConstSlice(v, config) + return rewriteValuegeneric_OpConstSlice(v) case OpConstString: - return rewriteValuegeneric_OpConstString(v, config) + return rewriteValuegeneric_OpConstString(v) case OpConvert: - return rewriteValuegeneric_OpConvert(v, config) + return rewriteValuegeneric_OpConvert(v) case OpCvt32Fto64F: - return rewriteValuegeneric_OpCvt32Fto64F(v, config) + return rewriteValuegeneric_OpCvt32Fto64F(v) case OpCvt64Fto32F: - return rewriteValuegeneric_OpCvt64Fto32F(v, config) + return rewriteValuegeneric_OpCvt64Fto32F(v) case OpDiv16: - return rewriteValuegeneric_OpDiv16(v, config) + return rewriteValuegeneric_OpDiv16(v) case OpDiv16u: - return rewriteValuegeneric_OpDiv16u(v, config) + return rewriteValuegeneric_OpDiv16u(v) case OpDiv32: - return rewriteValuegeneric_OpDiv32(v, config) + return rewriteValuegeneric_OpDiv32(v) case OpDiv32F: - return rewriteValuegeneric_OpDiv32F(v, config) + return rewriteValuegeneric_OpDiv32F(v) case OpDiv32u: - return rewriteValuegeneric_OpDiv32u(v, config) + return rewriteValuegeneric_OpDiv32u(v) case OpDiv64: - return rewriteValuegeneric_OpDiv64(v, config) + return rewriteValuegeneric_OpDiv64(v) case OpDiv64F: - return rewriteValuegeneric_OpDiv64F(v, config) + return rewriteValuegeneric_OpDiv64F(v) case OpDiv64u: - return rewriteValuegeneric_OpDiv64u(v, config) + return rewriteValuegeneric_OpDiv64u(v) case OpDiv8: - return rewriteValuegeneric_OpDiv8(v, config) + return rewriteValuegeneric_OpDiv8(v) case OpDiv8u: - return rewriteValuegeneric_OpDiv8u(v, config) + return rewriteValuegeneric_OpDiv8u(v) case OpEq16: - return rewriteValuegeneric_OpEq16(v, config) + return rewriteValuegeneric_OpEq16(v) case OpEq32: - return rewriteValuegeneric_OpEq32(v, config) + return rewriteValuegeneric_OpEq32(v) case OpEq64: - return rewriteValuegeneric_OpEq64(v, config) + return rewriteValuegeneric_OpEq64(v) case OpEq8: - return rewriteValuegeneric_OpEq8(v, config) + return rewriteValuegeneric_OpEq8(v) case OpEqB: - return rewriteValuegeneric_OpEqB(v, config) + return rewriteValuegeneric_OpEqB(v) case OpEqInter: - return rewriteValuegeneric_OpEqInter(v, config) + return rewriteValuegeneric_OpEqInter(v) case OpEqPtr: - return rewriteValuegeneric_OpEqPtr(v, config) + return rewriteValuegeneric_OpEqPtr(v) case OpEqSlice: - return rewriteValuegeneric_OpEqSlice(v, config) + return rewriteValuegeneric_OpEqSlice(v) case OpGeq16: - return rewriteValuegeneric_OpGeq16(v, config) + return rewriteValuegeneric_OpGeq16(v) case OpGeq16U: - return rewriteValuegeneric_OpGeq16U(v, config) + return rewriteValuegeneric_OpGeq16U(v) case OpGeq32: - return rewriteValuegeneric_OpGeq32(v, config) + return rewriteValuegeneric_OpGeq32(v) case OpGeq32U: - return rewriteValuegeneric_OpGeq32U(v, config) + return rewriteValuegeneric_OpGeq32U(v) case OpGeq64: - return rewriteValuegeneric_OpGeq64(v, config) + return rewriteValuegeneric_OpGeq64(v) case OpGeq64U: - return rewriteValuegeneric_OpGeq64U(v, config) + return rewriteValuegeneric_OpGeq64U(v) case OpGeq8: - return rewriteValuegeneric_OpGeq8(v, config) + return rewriteValuegeneric_OpGeq8(v) case OpGeq8U: - return rewriteValuegeneric_OpGeq8U(v, config) + return rewriteValuegeneric_OpGeq8U(v) case OpGreater16: - return rewriteValuegeneric_OpGreater16(v, config) + return rewriteValuegeneric_OpGreater16(v) case OpGreater16U: - return rewriteValuegeneric_OpGreater16U(v, config) + return rewriteValuegeneric_OpGreater16U(v) case OpGreater32: - return rewriteValuegeneric_OpGreater32(v, config) + return rewriteValuegeneric_OpGreater32(v) case OpGreater32U: - return rewriteValuegeneric_OpGreater32U(v, config) + return rewriteValuegeneric_OpGreater32U(v) case OpGreater64: - return rewriteValuegeneric_OpGreater64(v, config) + return rewriteValuegeneric_OpGreater64(v) case OpGreater64U: - return rewriteValuegeneric_OpGreater64U(v, config) + return rewriteValuegeneric_OpGreater64U(v) case OpGreater8: - return rewriteValuegeneric_OpGreater8(v, config) + return rewriteValuegeneric_OpGreater8(v) case OpGreater8U: - return rewriteValuegeneric_OpGreater8U(v, config) + return rewriteValuegeneric_OpGreater8U(v) case OpIMake: - return rewriteValuegeneric_OpIMake(v, config) + return rewriteValuegeneric_OpIMake(v) case OpInterCall: - return rewriteValuegeneric_OpInterCall(v, config) + return rewriteValuegeneric_OpInterCall(v) case OpIsInBounds: - return rewriteValuegeneric_OpIsInBounds(v, config) + return rewriteValuegeneric_OpIsInBounds(v) case OpIsNonNil: - return rewriteValuegeneric_OpIsNonNil(v, config) + return rewriteValuegeneric_OpIsNonNil(v) case OpIsSliceInBounds: - return rewriteValuegeneric_OpIsSliceInBounds(v, config) + return rewriteValuegeneric_OpIsSliceInBounds(v) case OpLeq16: - return rewriteValuegeneric_OpLeq16(v, config) + return rewriteValuegeneric_OpLeq16(v) case OpLeq16U: - return rewriteValuegeneric_OpLeq16U(v, config) + return rewriteValuegeneric_OpLeq16U(v) case OpLeq32: - return rewriteValuegeneric_OpLeq32(v, config) + return rewriteValuegeneric_OpLeq32(v) case OpLeq32U: - return rewriteValuegeneric_OpLeq32U(v, config) + return rewriteValuegeneric_OpLeq32U(v) case OpLeq64: - return rewriteValuegeneric_OpLeq64(v, config) + return rewriteValuegeneric_OpLeq64(v) case OpLeq64U: - return rewriteValuegeneric_OpLeq64U(v, config) + return rewriteValuegeneric_OpLeq64U(v) case OpLeq8: - return rewriteValuegeneric_OpLeq8(v, config) + return rewriteValuegeneric_OpLeq8(v) case OpLeq8U: - return rewriteValuegeneric_OpLeq8U(v, config) + return rewriteValuegeneric_OpLeq8U(v) case OpLess16: - return rewriteValuegeneric_OpLess16(v, config) + return rewriteValuegeneric_OpLess16(v) case OpLess16U: - return rewriteValuegeneric_OpLess16U(v, config) + return rewriteValuegeneric_OpLess16U(v) case OpLess32: - return rewriteValuegeneric_OpLess32(v, config) + return rewriteValuegeneric_OpLess32(v) case OpLess32U: - return rewriteValuegeneric_OpLess32U(v, config) + return rewriteValuegeneric_OpLess32U(v) case OpLess64: - return rewriteValuegeneric_OpLess64(v, config) + return rewriteValuegeneric_OpLess64(v) case OpLess64U: - return rewriteValuegeneric_OpLess64U(v, config) + return rewriteValuegeneric_OpLess64U(v) case OpLess8: - return rewriteValuegeneric_OpLess8(v, config) + return rewriteValuegeneric_OpLess8(v) case OpLess8U: - return rewriteValuegeneric_OpLess8U(v, config) + return rewriteValuegeneric_OpLess8U(v) case OpLoad: - return rewriteValuegeneric_OpLoad(v, config) + return rewriteValuegeneric_OpLoad(v) case OpLsh16x16: - return rewriteValuegeneric_OpLsh16x16(v, config) + return rewriteValuegeneric_OpLsh16x16(v) case OpLsh16x32: - return rewriteValuegeneric_OpLsh16x32(v, config) + return rewriteValuegeneric_OpLsh16x32(v) case OpLsh16x64: - return rewriteValuegeneric_OpLsh16x64(v, config) + return rewriteValuegeneric_OpLsh16x64(v) case OpLsh16x8: - return rewriteValuegeneric_OpLsh16x8(v, config) + return rewriteValuegeneric_OpLsh16x8(v) case OpLsh32x16: - return rewriteValuegeneric_OpLsh32x16(v, config) + return rewriteValuegeneric_OpLsh32x16(v) case OpLsh32x32: - return rewriteValuegeneric_OpLsh32x32(v, config) + return rewriteValuegeneric_OpLsh32x32(v) case OpLsh32x64: - return rewriteValuegeneric_OpLsh32x64(v, config) + return rewriteValuegeneric_OpLsh32x64(v) case OpLsh32x8: - return rewriteValuegeneric_OpLsh32x8(v, config) + return rewriteValuegeneric_OpLsh32x8(v) case OpLsh64x16: - return rewriteValuegeneric_OpLsh64x16(v, config) + return rewriteValuegeneric_OpLsh64x16(v) case OpLsh64x32: - return rewriteValuegeneric_OpLsh64x32(v, config) + return rewriteValuegeneric_OpLsh64x32(v) case OpLsh64x64: - return rewriteValuegeneric_OpLsh64x64(v, config) + return rewriteValuegeneric_OpLsh64x64(v) case OpLsh64x8: - return rewriteValuegeneric_OpLsh64x8(v, config) + return rewriteValuegeneric_OpLsh64x8(v) case OpLsh8x16: - return rewriteValuegeneric_OpLsh8x16(v, config) + return rewriteValuegeneric_OpLsh8x16(v) case OpLsh8x32: - return rewriteValuegeneric_OpLsh8x32(v, config) + return rewriteValuegeneric_OpLsh8x32(v) case OpLsh8x64: - return rewriteValuegeneric_OpLsh8x64(v, config) + return rewriteValuegeneric_OpLsh8x64(v) case OpLsh8x8: - return rewriteValuegeneric_OpLsh8x8(v, config) + return rewriteValuegeneric_OpLsh8x8(v) case OpMod16: - return rewriteValuegeneric_OpMod16(v, config) + return rewriteValuegeneric_OpMod16(v) case OpMod16u: - return rewriteValuegeneric_OpMod16u(v, config) + return rewriteValuegeneric_OpMod16u(v) case OpMod32: - return rewriteValuegeneric_OpMod32(v, config) + return rewriteValuegeneric_OpMod32(v) case OpMod32u: - return rewriteValuegeneric_OpMod32u(v, config) + return rewriteValuegeneric_OpMod32u(v) case OpMod64: - return rewriteValuegeneric_OpMod64(v, config) + return rewriteValuegeneric_OpMod64(v) case OpMod64u: - return rewriteValuegeneric_OpMod64u(v, config) + return rewriteValuegeneric_OpMod64u(v) case OpMod8: - return rewriteValuegeneric_OpMod8(v, config) + return rewriteValuegeneric_OpMod8(v) case OpMod8u: - return rewriteValuegeneric_OpMod8u(v, config) + return rewriteValuegeneric_OpMod8u(v) case OpMul16: - return rewriteValuegeneric_OpMul16(v, config) + return rewriteValuegeneric_OpMul16(v) case OpMul32: - return rewriteValuegeneric_OpMul32(v, config) + return rewriteValuegeneric_OpMul32(v) case OpMul32F: - return rewriteValuegeneric_OpMul32F(v, config) + return rewriteValuegeneric_OpMul32F(v) case OpMul64: - return rewriteValuegeneric_OpMul64(v, config) + return rewriteValuegeneric_OpMul64(v) case OpMul64F: - return rewriteValuegeneric_OpMul64F(v, config) + return rewriteValuegeneric_OpMul64F(v) case OpMul8: - return rewriteValuegeneric_OpMul8(v, config) + return rewriteValuegeneric_OpMul8(v) case OpNeg16: - return rewriteValuegeneric_OpNeg16(v, config) + return rewriteValuegeneric_OpNeg16(v) case OpNeg32: - return rewriteValuegeneric_OpNeg32(v, config) + return rewriteValuegeneric_OpNeg32(v) case OpNeg32F: - return rewriteValuegeneric_OpNeg32F(v, config) + return rewriteValuegeneric_OpNeg32F(v) case OpNeg64: - return rewriteValuegeneric_OpNeg64(v, config) + return rewriteValuegeneric_OpNeg64(v) case OpNeg64F: - return rewriteValuegeneric_OpNeg64F(v, config) + return rewriteValuegeneric_OpNeg64F(v) case OpNeg8: - return rewriteValuegeneric_OpNeg8(v, config) + return rewriteValuegeneric_OpNeg8(v) case OpNeq16: - return rewriteValuegeneric_OpNeq16(v, config) + return rewriteValuegeneric_OpNeq16(v) case OpNeq32: - return rewriteValuegeneric_OpNeq32(v, config) + return rewriteValuegeneric_OpNeq32(v) case OpNeq64: - return rewriteValuegeneric_OpNeq64(v, config) + return rewriteValuegeneric_OpNeq64(v) case OpNeq8: - return rewriteValuegeneric_OpNeq8(v, config) + return rewriteValuegeneric_OpNeq8(v) case OpNeqB: - return rewriteValuegeneric_OpNeqB(v, config) + return rewriteValuegeneric_OpNeqB(v) case OpNeqInter: - return rewriteValuegeneric_OpNeqInter(v, config) + return rewriteValuegeneric_OpNeqInter(v) case OpNeqPtr: - return rewriteValuegeneric_OpNeqPtr(v, config) + return rewriteValuegeneric_OpNeqPtr(v) case OpNeqSlice: - return rewriteValuegeneric_OpNeqSlice(v, config) + return rewriteValuegeneric_OpNeqSlice(v) case OpNilCheck: - return rewriteValuegeneric_OpNilCheck(v, config) + return rewriteValuegeneric_OpNilCheck(v) case OpNot: - return rewriteValuegeneric_OpNot(v, config) + return rewriteValuegeneric_OpNot(v) case OpOffPtr: - return rewriteValuegeneric_OpOffPtr(v, config) + return rewriteValuegeneric_OpOffPtr(v) case OpOr16: - return rewriteValuegeneric_OpOr16(v, config) + return rewriteValuegeneric_OpOr16(v) case OpOr32: - return rewriteValuegeneric_OpOr32(v, config) + return rewriteValuegeneric_OpOr32(v) case OpOr64: - return rewriteValuegeneric_OpOr64(v, config) + return rewriteValuegeneric_OpOr64(v) case OpOr8: - return rewriteValuegeneric_OpOr8(v, config) + return rewriteValuegeneric_OpOr8(v) case OpPhi: - return rewriteValuegeneric_OpPhi(v, config) + return rewriteValuegeneric_OpPhi(v) case OpPtrIndex: - return rewriteValuegeneric_OpPtrIndex(v, config) + return rewriteValuegeneric_OpPtrIndex(v) case OpRound32F: - return rewriteValuegeneric_OpRound32F(v, config) + return rewriteValuegeneric_OpRound32F(v) case OpRound64F: - return rewriteValuegeneric_OpRound64F(v, config) + return rewriteValuegeneric_OpRound64F(v) case OpRsh16Ux16: - return rewriteValuegeneric_OpRsh16Ux16(v, config) + return rewriteValuegeneric_OpRsh16Ux16(v) case OpRsh16Ux32: - return rewriteValuegeneric_OpRsh16Ux32(v, config) + return rewriteValuegeneric_OpRsh16Ux32(v) case OpRsh16Ux64: - return rewriteValuegeneric_OpRsh16Ux64(v, config) + return rewriteValuegeneric_OpRsh16Ux64(v) case OpRsh16Ux8: - return rewriteValuegeneric_OpRsh16Ux8(v, config) + return rewriteValuegeneric_OpRsh16Ux8(v) case OpRsh16x16: - return rewriteValuegeneric_OpRsh16x16(v, config) + return rewriteValuegeneric_OpRsh16x16(v) case OpRsh16x32: - return rewriteValuegeneric_OpRsh16x32(v, config) + return rewriteValuegeneric_OpRsh16x32(v) case OpRsh16x64: - return rewriteValuegeneric_OpRsh16x64(v, config) + return rewriteValuegeneric_OpRsh16x64(v) case OpRsh16x8: - return rewriteValuegeneric_OpRsh16x8(v, config) + return rewriteValuegeneric_OpRsh16x8(v) case OpRsh32Ux16: - return rewriteValuegeneric_OpRsh32Ux16(v, config) + return rewriteValuegeneric_OpRsh32Ux16(v) case OpRsh32Ux32: - return rewriteValuegeneric_OpRsh32Ux32(v, config) + return rewriteValuegeneric_OpRsh32Ux32(v) case OpRsh32Ux64: - return rewriteValuegeneric_OpRsh32Ux64(v, config) + return rewriteValuegeneric_OpRsh32Ux64(v) case OpRsh32Ux8: - return rewriteValuegeneric_OpRsh32Ux8(v, config) + return rewriteValuegeneric_OpRsh32Ux8(v) case OpRsh32x16: - return rewriteValuegeneric_OpRsh32x16(v, config) + return rewriteValuegeneric_OpRsh32x16(v) case OpRsh32x32: - return rewriteValuegeneric_OpRsh32x32(v, config) + return rewriteValuegeneric_OpRsh32x32(v) case OpRsh32x64: - return rewriteValuegeneric_OpRsh32x64(v, config) + return rewriteValuegeneric_OpRsh32x64(v) case OpRsh32x8: - return rewriteValuegeneric_OpRsh32x8(v, config) + return rewriteValuegeneric_OpRsh32x8(v) case OpRsh64Ux16: - return rewriteValuegeneric_OpRsh64Ux16(v, config) + return rewriteValuegeneric_OpRsh64Ux16(v) case OpRsh64Ux32: - return rewriteValuegeneric_OpRsh64Ux32(v, config) + return rewriteValuegeneric_OpRsh64Ux32(v) case OpRsh64Ux64: - return rewriteValuegeneric_OpRsh64Ux64(v, config) + return rewriteValuegeneric_OpRsh64Ux64(v) case OpRsh64Ux8: - return rewriteValuegeneric_OpRsh64Ux8(v, config) + return rewriteValuegeneric_OpRsh64Ux8(v) case OpRsh64x16: - return rewriteValuegeneric_OpRsh64x16(v, config) + return rewriteValuegeneric_OpRsh64x16(v) case OpRsh64x32: - return rewriteValuegeneric_OpRsh64x32(v, config) + return rewriteValuegeneric_OpRsh64x32(v) case OpRsh64x64: - return rewriteValuegeneric_OpRsh64x64(v, config) + return rewriteValuegeneric_OpRsh64x64(v) case OpRsh64x8: - return rewriteValuegeneric_OpRsh64x8(v, config) + return rewriteValuegeneric_OpRsh64x8(v) case OpRsh8Ux16: - return rewriteValuegeneric_OpRsh8Ux16(v, config) + return rewriteValuegeneric_OpRsh8Ux16(v) case OpRsh8Ux32: - return rewriteValuegeneric_OpRsh8Ux32(v, config) + return rewriteValuegeneric_OpRsh8Ux32(v) case OpRsh8Ux64: - return rewriteValuegeneric_OpRsh8Ux64(v, config) + return rewriteValuegeneric_OpRsh8Ux64(v) case OpRsh8Ux8: - return rewriteValuegeneric_OpRsh8Ux8(v, config) + return rewriteValuegeneric_OpRsh8Ux8(v) case OpRsh8x16: - return rewriteValuegeneric_OpRsh8x16(v, config) + return rewriteValuegeneric_OpRsh8x16(v) case OpRsh8x32: - return rewriteValuegeneric_OpRsh8x32(v, config) + return rewriteValuegeneric_OpRsh8x32(v) case OpRsh8x64: - return rewriteValuegeneric_OpRsh8x64(v, config) + return rewriteValuegeneric_OpRsh8x64(v) case OpRsh8x8: - return rewriteValuegeneric_OpRsh8x8(v, config) + return rewriteValuegeneric_OpRsh8x8(v) case OpSignExt16to32: - return rewriteValuegeneric_OpSignExt16to32(v, config) + return rewriteValuegeneric_OpSignExt16to32(v) case OpSignExt16to64: - return rewriteValuegeneric_OpSignExt16to64(v, config) + return rewriteValuegeneric_OpSignExt16to64(v) case OpSignExt32to64: - return rewriteValuegeneric_OpSignExt32to64(v, config) + return rewriteValuegeneric_OpSignExt32to64(v) case OpSignExt8to16: - return rewriteValuegeneric_OpSignExt8to16(v, config) + return rewriteValuegeneric_OpSignExt8to16(v) case OpSignExt8to32: - return rewriteValuegeneric_OpSignExt8to32(v, config) + return rewriteValuegeneric_OpSignExt8to32(v) case OpSignExt8to64: - return rewriteValuegeneric_OpSignExt8to64(v, config) + return rewriteValuegeneric_OpSignExt8to64(v) case OpSliceCap: - return rewriteValuegeneric_OpSliceCap(v, config) + return rewriteValuegeneric_OpSliceCap(v) case OpSliceLen: - return rewriteValuegeneric_OpSliceLen(v, config) + return rewriteValuegeneric_OpSliceLen(v) case OpSlicePtr: - return rewriteValuegeneric_OpSlicePtr(v, config) + return rewriteValuegeneric_OpSlicePtr(v) case OpSlicemask: - return rewriteValuegeneric_OpSlicemask(v, config) + return rewriteValuegeneric_OpSlicemask(v) case OpSqrt: - return rewriteValuegeneric_OpSqrt(v, config) + return rewriteValuegeneric_OpSqrt(v) case OpStore: - return rewriteValuegeneric_OpStore(v, config) + return rewriteValuegeneric_OpStore(v) case OpStringLen: - return rewriteValuegeneric_OpStringLen(v, config) + return rewriteValuegeneric_OpStringLen(v) case OpStringPtr: - return rewriteValuegeneric_OpStringPtr(v, config) + return rewriteValuegeneric_OpStringPtr(v) case OpStructSelect: - return rewriteValuegeneric_OpStructSelect(v, config) + return rewriteValuegeneric_OpStructSelect(v) case OpSub16: - return rewriteValuegeneric_OpSub16(v, config) + return rewriteValuegeneric_OpSub16(v) case OpSub32: - return rewriteValuegeneric_OpSub32(v, config) + return rewriteValuegeneric_OpSub32(v) case OpSub32F: - return rewriteValuegeneric_OpSub32F(v, config) + return rewriteValuegeneric_OpSub32F(v) case OpSub64: - return rewriteValuegeneric_OpSub64(v, config) + return rewriteValuegeneric_OpSub64(v) case OpSub64F: - return rewriteValuegeneric_OpSub64F(v, config) + return rewriteValuegeneric_OpSub64F(v) case OpSub8: - return rewriteValuegeneric_OpSub8(v, config) + return rewriteValuegeneric_OpSub8(v) case OpTrunc16to8: - return rewriteValuegeneric_OpTrunc16to8(v, config) + return rewriteValuegeneric_OpTrunc16to8(v) case OpTrunc32to16: - return rewriteValuegeneric_OpTrunc32to16(v, config) + return rewriteValuegeneric_OpTrunc32to16(v) case OpTrunc32to8: - return rewriteValuegeneric_OpTrunc32to8(v, config) + return rewriteValuegeneric_OpTrunc32to8(v) case OpTrunc64to16: - return rewriteValuegeneric_OpTrunc64to16(v, config) + return rewriteValuegeneric_OpTrunc64to16(v) case OpTrunc64to32: - return rewriteValuegeneric_OpTrunc64to32(v, config) + return rewriteValuegeneric_OpTrunc64to32(v) case OpTrunc64to8: - return rewriteValuegeneric_OpTrunc64to8(v, config) + return rewriteValuegeneric_OpTrunc64to8(v) case OpXor16: - return rewriteValuegeneric_OpXor16(v, config) + return rewriteValuegeneric_OpXor16(v) case OpXor32: - return rewriteValuegeneric_OpXor32(v, config) + return rewriteValuegeneric_OpXor32(v) case OpXor64: - return rewriteValuegeneric_OpXor64(v, config) + return rewriteValuegeneric_OpXor64(v) case OpXor8: - return rewriteValuegeneric_OpXor8(v, config) + return rewriteValuegeneric_OpXor8(v) case OpZero: - return rewriteValuegeneric_OpZero(v, config) + return rewriteValuegeneric_OpZero(v) case OpZeroExt16to32: - return rewriteValuegeneric_OpZeroExt16to32(v, config) + return rewriteValuegeneric_OpZeroExt16to32(v) case OpZeroExt16to64: - return rewriteValuegeneric_OpZeroExt16to64(v, config) + return rewriteValuegeneric_OpZeroExt16to64(v) case OpZeroExt32to64: - return rewriteValuegeneric_OpZeroExt32to64(v, config) + return rewriteValuegeneric_OpZeroExt32to64(v) case OpZeroExt8to16: - return rewriteValuegeneric_OpZeroExt8to16(v, config) + return rewriteValuegeneric_OpZeroExt8to16(v) case OpZeroExt8to32: - return rewriteValuegeneric_OpZeroExt8to32(v, config) + return rewriteValuegeneric_OpZeroExt8to32(v) case OpZeroExt8to64: - return rewriteValuegeneric_OpZeroExt8to64(v, config) + return rewriteValuegeneric_OpZeroExt8to64(v) } return false } -func rewriteValuegeneric_OpAdd16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpAdd16(v *Value) bool { b := v.Block _ = b // match: (Add16 (Const16 [c]) (Const16 [d])) @@ -737,7 +737,7 @@ func rewriteValuegeneric_OpAdd16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAdd32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpAdd32(v *Value) bool { b := v.Block _ = b // match: (Add32 (Const32 [c]) (Const32 [d])) @@ -1055,9 +1055,7 @@ func rewriteValuegeneric_OpAdd32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAdd32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpAdd32F(v *Value) bool { // match: (Add32F (Const32F [c]) (Const32F [d])) // cond: // result: (Const32F [f2i(float64(i2f32(c) + i2f32(d)))]) @@ -1112,7 +1110,7 @@ func rewriteValuegeneric_OpAdd32F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpAdd64(v *Value) bool { b := v.Block _ = b // match: (Add64 (Const64 [c]) (Const64 [d])) @@ -1430,9 +1428,7 @@ func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAdd64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpAdd64F(v *Value) bool { // match: (Add64F (Const64F [c]) (Const64F [d])) // cond: // result: (Const64F [f2i(i2f(c) + i2f(d))]) @@ -1487,7 +1483,7 @@ func rewriteValuegeneric_OpAdd64F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpAdd8(v *Value) bool { b := v.Block _ = b // match: (Add8 (Const8 [c]) (Const8 [d])) @@ -1805,9 +1801,7 @@ func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAddPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpAddPtr(v *Value) bool { // match: (AddPtr <t> x (Const64 [c])) // cond: // result: (OffPtr <t> x [c]) @@ -1844,7 +1838,7 @@ func rewriteValuegeneric_OpAddPtr(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAnd16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpAnd16(v *Value) bool { b := v.Block _ = b // match: (And16 (Const16 [c]) (Const16 [d])) @@ -2078,7 +2072,7 @@ func rewriteValuegeneric_OpAnd16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpAnd32(v *Value) bool { b := v.Block _ = b // match: (And32 (Const32 [c]) (Const32 [d])) @@ -2312,7 +2306,7 @@ func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpAnd64(v *Value) bool { b := v.Block _ = b // match: (And64 (Const64 [c]) (Const64 [d])) @@ -2598,7 +2592,7 @@ func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpAnd8(v *Value) bool { b := v.Block _ = b // match: (And8 (Const8 [c]) (Const8 [d])) @@ -2832,12 +2826,16 @@ func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { +func rewriteValuegeneric_OpArg(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Arg {n} [off]) // cond: v.Type.IsString() - // result: (StringMake (Arg <config.fe.TypeBytePtr()> {n} [off]) (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize])) + // result: (StringMake (Arg <fe.TypeBytePtr()> {n} [off]) (Arg <fe.TypeInt()> {n} [off+config.PtrSize])) for { off := v.AuxInt n := v.Aux @@ -2845,11 +2843,11 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { break } v.reset(OpStringMake) - v0 := b.NewValue0(v.Pos, OpArg, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpArg, fe.TypeBytePtr()) v0.AuxInt = off v0.Aux = n v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpArg, config.fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpArg, fe.TypeInt()) v1.AuxInt = off + config.PtrSize v1.Aux = n v.AddArg(v1) @@ -2857,7 +2855,7 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { } // match: (Arg {n} [off]) // cond: v.Type.IsSlice() - // result: (SliceMake (Arg <v.Type.ElemType().PtrTo()> {n} [off]) (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize]) (Arg <config.fe.TypeInt()> {n} [off+2*config.PtrSize])) + // result: (SliceMake (Arg <v.Type.ElemType().PtrTo()> {n} [off]) (Arg <fe.TypeInt()> {n} [off+config.PtrSize]) (Arg <fe.TypeInt()> {n} [off+2*config.PtrSize])) for { off := v.AuxInt n := v.Aux @@ -2869,11 +2867,11 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { v0.AuxInt = off v0.Aux = n v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpArg, config.fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpArg, fe.TypeInt()) v1.AuxInt = off + config.PtrSize v1.Aux = n v.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpArg, config.fe.TypeInt()) + v2 := b.NewValue0(v.Pos, OpArg, fe.TypeInt()) v2.AuxInt = off + 2*config.PtrSize v2.Aux = n v.AddArg(v2) @@ -2881,7 +2879,7 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { } // match: (Arg {n} [off]) // cond: v.Type.IsInterface() - // result: (IMake (Arg <config.fe.TypeBytePtr()> {n} [off]) (Arg <config.fe.TypeBytePtr()> {n} [off+config.PtrSize])) + // result: (IMake (Arg <fe.TypeBytePtr()> {n} [off]) (Arg <fe.TypeBytePtr()> {n} [off+config.PtrSize])) for { off := v.AuxInt n := v.Aux @@ -2889,11 +2887,11 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { break } v.reset(OpIMake) - v0 := b.NewValue0(v.Pos, OpArg, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpArg, fe.TypeBytePtr()) v0.AuxInt = off v0.Aux = n v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpArg, config.fe.TypeBytePtr()) + v1 := b.NewValue0(v.Pos, OpArg, fe.TypeBytePtr()) v1.AuxInt = off + config.PtrSize v1.Aux = n v.AddArg(v1) @@ -2901,7 +2899,7 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { } // match: (Arg {n} [off]) // cond: v.Type.IsComplex() && v.Type.Size() == 16 - // result: (ComplexMake (Arg <config.fe.TypeFloat64()> {n} [off]) (Arg <config.fe.TypeFloat64()> {n} [off+8])) + // result: (ComplexMake (Arg <fe.TypeFloat64()> {n} [off]) (Arg <fe.TypeFloat64()> {n} [off+8])) for { off := v.AuxInt n := v.Aux @@ -2909,11 +2907,11 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { break } v.reset(OpComplexMake) - v0 := b.NewValue0(v.Pos, OpArg, config.fe.TypeFloat64()) + v0 := b.NewValue0(v.Pos, OpArg, fe.TypeFloat64()) v0.AuxInt = off v0.Aux = n v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpArg, config.fe.TypeFloat64()) + v1 := b.NewValue0(v.Pos, OpArg, fe.TypeFloat64()) v1.AuxInt = off + 8 v1.Aux = n v.AddArg(v1) @@ -2921,7 +2919,7 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { } // match: (Arg {n} [off]) // cond: v.Type.IsComplex() && v.Type.Size() == 8 - // result: (ComplexMake (Arg <config.fe.TypeFloat32()> {n} [off]) (Arg <config.fe.TypeFloat32()> {n} [off+4])) + // result: (ComplexMake (Arg <fe.TypeFloat32()> {n} [off]) (Arg <fe.TypeFloat32()> {n} [off+4])) for { off := v.AuxInt n := v.Aux @@ -2929,35 +2927,35 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { break } v.reset(OpComplexMake) - v0 := b.NewValue0(v.Pos, OpArg, config.fe.TypeFloat32()) + v0 := b.NewValue0(v.Pos, OpArg, fe.TypeFloat32()) v0.AuxInt = off v0.Aux = n v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpArg, config.fe.TypeFloat32()) + v1 := b.NewValue0(v.Pos, OpArg, fe.TypeFloat32()) v1.AuxInt = off + 4 v1.Aux = n v.AddArg(v1) return true } // match: (Arg <t>) - // cond: t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) // result: (StructMake0) for { t := v.Type - if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) { break } v.reset(OpStructMake0) return true } // match: (Arg <t> {n} [off]) - // cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) // result: (StructMake1 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)])) for { t := v.Type off := v.AuxInt n := v.Aux - if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) { break } v.reset(OpStructMake1) @@ -2968,13 +2966,13 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { return true } // match: (Arg <t> {n} [off]) - // cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t) // result: (StructMake2 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)])) for { t := v.Type off := v.AuxInt n := v.Aux - if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) { break } v.reset(OpStructMake2) @@ -2989,13 +2987,13 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { return true } // match: (Arg <t> {n} [off]) - // cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t) // result: (StructMake3 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)])) for { t := v.Type off := v.AuxInt n := v.Aux - if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) { break } v.reset(OpStructMake3) @@ -3014,13 +3012,13 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { return true } // match: (Arg <t> {n} [off]) - // cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t) // result: (StructMake4 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)]) (Arg <t.FieldType(3)> {n} [off+t.FieldOff(3)])) for { t := v.Type off := v.AuxInt n := v.Aux - if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) { break } v.reset(OpStructMake4) @@ -3054,13 +3052,13 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { return true } // match: (Arg <t> {n} [off]) - // cond: t.IsArray() && t.NumElem() == 1 && config.fe.CanSSA(t) + // cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t) // result: (ArrayMake1 (Arg <t.ElemType()> {n} [off])) for { t := v.Type off := v.AuxInt n := v.Aux - if !(t.IsArray() && t.NumElem() == 1 && config.fe.CanSSA(t)) { + if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) { break } v.reset(OpArrayMake1) @@ -3072,9 +3070,7 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpArraySelect(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpArraySelect(v *Value) bool { // match: (ArraySelect (ArrayMake1 x)) // cond: // result: x @@ -3125,9 +3121,7 @@ func rewriteValuegeneric_OpArraySelect(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpCom16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpCom16(v *Value) bool { // match: (Com16 (Com16 x)) // cond: // result: x @@ -3144,9 +3138,7 @@ func rewriteValuegeneric_OpCom16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpCom32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpCom32(v *Value) bool { // match: (Com32 (Com32 x)) // cond: // result: x @@ -3163,9 +3155,7 @@ func rewriteValuegeneric_OpCom32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpCom64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpCom64(v *Value) bool { // match: (Com64 (Com64 x)) // cond: // result: x @@ -3182,9 +3172,7 @@ func rewriteValuegeneric_OpCom64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpCom8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpCom8(v *Value) bool { // match: (Com8 (Com8 x)) // cond: // result: x @@ -3201,27 +3189,35 @@ func rewriteValuegeneric_OpCom8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpConstInterface(v *Value, config *Config) bool { +func rewriteValuegeneric_OpConstInterface(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ConstInterface) // cond: - // result: (IMake (ConstNil <config.fe.TypeBytePtr()>) (ConstNil <config.fe.TypeBytePtr()>)) + // result: (IMake (ConstNil <fe.TypeBytePtr()>) (ConstNil <fe.TypeBytePtr()>)) for { v.reset(OpIMake) - v0 := b.NewValue0(v.Pos, OpConstNil, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpConstNil, fe.TypeBytePtr()) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpConstNil, config.fe.TypeBytePtr()) + v1 := b.NewValue0(v.Pos, OpConstNil, fe.TypeBytePtr()) v.AddArg(v1) return true } } -func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { +func rewriteValuegeneric_OpConstSlice(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ConstSlice) // cond: config.PtrSize == 4 - // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const32 <config.fe.TypeInt()> [0]) (Const32 <config.fe.TypeInt()> [0])) + // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const32 <fe.TypeInt()> [0]) (Const32 <fe.TypeInt()> [0])) for { if !(config.PtrSize == 4) { break @@ -3229,17 +3225,17 @@ func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { v.reset(OpSliceMake) v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.ElemType().PtrTo()) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt()) v1.AuxInt = 0 v.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeInt()) + v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt()) v2.AuxInt = 0 v.AddArg(v2) return true } // match: (ConstSlice) // cond: config.PtrSize == 8 - // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const64 <config.fe.TypeInt()> [0]) (Const64 <config.fe.TypeInt()> [0])) + // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const64 <fe.TypeInt()> [0]) (Const64 <fe.TypeInt()> [0])) for { if !(config.PtrSize == 8) { break @@ -3247,94 +3243,96 @@ func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { v.reset(OpSliceMake) v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.ElemType().PtrTo()) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt()) v1.AuxInt = 0 v.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeInt()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt()) v2.AuxInt = 0 v.AddArg(v2) return true } return false } -func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { +func rewriteValuegeneric_OpConstString(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (ConstString {s}) // cond: config.PtrSize == 4 && s.(string) == "" - // result: (StringMake (ConstNil) (Const32 <config.fe.TypeInt()> [0])) + // result: (StringMake (ConstNil) (Const32 <fe.TypeInt()> [0])) for { s := v.Aux if !(config.PtrSize == 4 && s.(string) == "") { break } v.reset(OpStringMake) - v0 := b.NewValue0(v.Pos, OpConstNil, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpConstNil, fe.TypeBytePtr()) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt()) v1.AuxInt = 0 v.AddArg(v1) return true } // match: (ConstString {s}) // cond: config.PtrSize == 8 && s.(string) == "" - // result: (StringMake (ConstNil) (Const64 <config.fe.TypeInt()> [0])) + // result: (StringMake (ConstNil) (Const64 <fe.TypeInt()> [0])) for { s := v.Aux if !(config.PtrSize == 8 && s.(string) == "") { break } v.reset(OpStringMake) - v0 := b.NewValue0(v.Pos, OpConstNil, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpConstNil, fe.TypeBytePtr()) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt()) v1.AuxInt = 0 v.AddArg(v1) return true } // match: (ConstString {s}) // cond: config.PtrSize == 4 && s.(string) != "" - // result: (StringMake (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))} (SB)) (Const32 <config.fe.TypeInt()> [int64(len(s.(string)))])) + // result: (StringMake (Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))} (SB)) (Const32 <fe.TypeInt()> [int64(len(s.(string)))])) for { s := v.Aux if !(config.PtrSize == 4 && s.(string) != "") { break } v.reset(OpStringMake) - v0 := b.NewValue0(v.Pos, OpAddr, config.fe.TypeBytePtr()) - v0.Aux = config.fe.StringData(s.(string)) - v1 := b.NewValue0(v.Pos, OpSB, config.fe.TypeUintptr()) + v0 := b.NewValue0(v.Pos, OpAddr, fe.TypeBytePtr()) + v0.Aux = fe.StringData(s.(string)) + v1 := b.NewValue0(v.Pos, OpSB, fe.TypeUintptr()) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeInt()) + v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt()) v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) return true } // match: (ConstString {s}) // cond: config.PtrSize == 8 && s.(string) != "" - // result: (StringMake (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))} (SB)) (Const64 <config.fe.TypeInt()> [int64(len(s.(string)))])) + // result: (StringMake (Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))} (SB)) (Const64 <fe.TypeInt()> [int64(len(s.(string)))])) for { s := v.Aux if !(config.PtrSize == 8 && s.(string) != "") { break } v.reset(OpStringMake) - v0 := b.NewValue0(v.Pos, OpAddr, config.fe.TypeBytePtr()) - v0.Aux = config.fe.StringData(s.(string)) - v1 := b.NewValue0(v.Pos, OpSB, config.fe.TypeUintptr()) + v0 := b.NewValue0(v.Pos, OpAddr, fe.TypeBytePtr()) + v0.Aux = fe.StringData(s.(string)) + v1 := b.NewValue0(v.Pos, OpSB, fe.TypeUintptr()) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeInt()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt()) v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) return true } return false } -func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpConvert(v *Value) bool { // match: (Convert (Add64 (Convert ptr mem) off) mem) // cond: // result: (Add64 ptr off) @@ -3401,9 +3399,7 @@ func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpCvt32Fto64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool { // match: (Cvt32Fto64F (Const32F [c])) // cond: // result: (Const64F [c]) @@ -3419,9 +3415,7 @@ func rewriteValuegeneric_OpCvt32Fto64F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpCvt64Fto32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool { // match: (Cvt64Fto32F (Const64F [c])) // cond: // result: (Const32F [f2i(float64(i2f32(c)))]) @@ -3437,9 +3431,13 @@ func rewriteValuegeneric_OpCvt64Fto32F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpDiv16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpDiv16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16 (Const16 [c]) (Const16 [d])) // cond: d != 0 // result: (Const16 [int64(int16(c)/int16(d))]) @@ -3486,7 +3484,7 @@ func rewriteValuegeneric_OpDiv16(v *Value, config *Config) bool { } // match: (Div16 <t> x (Const16 [-1<<15])) // cond: - // result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <config.fe.TypeUInt64()> [15])) + // result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <fe.TypeUInt64()> [15])) for { t := v.Type x := v.Args[0] @@ -3504,14 +3502,14 @@ func rewriteValuegeneric_OpDiv16(v *Value, config *Config) bool { v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 15 v.AddArg(v2) return true } // match: (Div16 <t> n (Const16 [c])) // cond: isPowerOfTwo(c) - // result: (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <config.fe.TypeUInt64()> [15])) (Const64 <config.fe.TypeUInt64()> [16-log2(c)]))) (Const64 <config.fe.TypeUInt64()> [log2(c)])) + // result: (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <fe.TypeUInt64()> [15])) (Const64 <fe.TypeUInt64()> [16-log2(c)]))) (Const64 <fe.TypeUInt64()> [log2(c)])) for { t := v.Type n := v.Args[0] @@ -3529,23 +3527,23 @@ func rewriteValuegeneric_OpDiv16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpRsh16Ux64, t) v2 := b.NewValue0(v.Pos, OpRsh16x64, t) v2.AddArg(n) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = 15 v2.AddArg(v3) v1.AddArg(v2) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 16 - log2(c) v1.AddArg(v4) v0.AddArg(v1) v.AddArg(v0) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = log2(c) v.AddArg(v5) return true } // match: (Div16 <t> x (Const16 [c])) // cond: smagicOK(16,c) - // result: (Sub16 <t> (Rsh32x64 <t> (Mul32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [int64(smagic(16,c).m)]) (SignExt16to32 x)) (Const64 <config.fe.TypeUInt64()> [16+smagic(16,c).s])) (Rsh32x64 <t> (SignExt16to32 x) (Const64 <config.fe.TypeUInt64()> [31]))) + // result: (Sub16 <t> (Rsh32x64 <t> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(smagic(16,c).m)]) (SignExt16to32 x)) (Const64 <fe.TypeUInt64()> [16+smagic(16,c).s])) (Rsh32x64 <t> (SignExt16to32 x) (Const64 <fe.TypeUInt64()> [31]))) for { t := v.Type x := v.Args[0] @@ -3560,23 +3558,23 @@ func rewriteValuegeneric_OpDiv16(v *Value, config *Config) bool { v.reset(OpSub16) v.Type = t v0 := b.NewValue0(v.Pos, OpRsh32x64, t) - v1 := b.NewValue0(v.Pos, OpMul32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v2.AuxInt = int64(smagic(16, c).m) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v3 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v3.AddArg(x) v1.AddArg(v3) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 16 + smagic(16, c).s v0.AddArg(v4) v.AddArg(v0) v5 := b.NewValue0(v.Pos, OpRsh32x64, t) - v6 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32()) + v6 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32()) v6.AddArg(x) v5.AddArg(v6) - v7 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v7 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v7.AuxInt = 31 v5.AddArg(v7) v.AddArg(v5) @@ -3584,9 +3582,13 @@ func rewriteValuegeneric_OpDiv16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { +func rewriteValuegeneric_OpDiv16u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div16u (Const16 [c]) (Const16 [d])) // cond: d != 0 // result: (Const16 [int64(int16(uint16(c)/uint16(d)))]) @@ -3610,7 +3612,7 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { } // match: (Div16u n (Const16 [c])) // cond: isPowerOfTwo(c&0xffff) - // result: (Rsh16Ux64 n (Const64 <config.fe.TypeUInt64()> [log2(c&0xffff)])) + // result: (Rsh16Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffff)])) for { n := v.Args[0] v_1 := v.Args[1] @@ -3623,14 +3625,14 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { } v.reset(OpRsh16Ux64) v.AddArg(n) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = log2(c & 0xffff) v.AddArg(v0) return true } // match: (Div16u x (Const16 [c])) // cond: umagicOK(16, c) && config.RegSize == 8 - // result: (Trunc64to16 (Rsh64Ux64 <config.fe.TypeUInt64()> (Mul64 <config.fe.TypeUInt64()> (Const64 <config.fe.TypeUInt64()> [int64(1<<16+umagic(16,c).m)]) (ZeroExt16to64 x)) (Const64 <config.fe.TypeUInt64()> [16+umagic(16,c).s]))) + // result: (Trunc64to16 (Rsh64Ux64 <fe.TypeUInt64()> (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<16+umagic(16,c).m)]) (ZeroExt16to64 x)) (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s]))) for { x := v.Args[0] v_1 := v.Args[1] @@ -3642,16 +3644,16 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { break } v.reset(OpTrunc64to16) - v0 := b.NewValue0(v.Pos, OpRsh64Ux64, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpMul64, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = int64(1<<16 + umagic(16, c).m) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64()) v3.AddArg(x) v1.AddArg(v3) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 16 + umagic(16, c).s v0.AddArg(v4) v.AddArg(v0) @@ -3659,7 +3661,7 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { } // match: (Div16u x (Const16 [c])) // cond: umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0 - // result: (Trunc32to16 (Rsh32Ux64 <config.fe.TypeUInt32()> (Mul32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [int64(1<<15+umagic(16,c).m/2)]) (ZeroExt16to32 x)) (Const64 <config.fe.TypeUInt64()> [16+umagic(16,c).s-1]))) + // result: (Trunc32to16 (Rsh32Ux64 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(1<<15+umagic(16,c).m/2)]) (ZeroExt16to32 x)) (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1]))) for { x := v.Args[0] v_1 := v.Args[1] @@ -3671,16 +3673,16 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { break } v.reset(OpTrunc32to16) - v0 := b.NewValue0(v.Pos, OpRsh32Ux64, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpMul32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v2.AuxInt = int64(1<<15 + umagic(16, c).m/2) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v3.AddArg(x) v1.AddArg(v3) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 16 + umagic(16, c).s - 1 v0.AddArg(v4) v.AddArg(v0) @@ -3688,7 +3690,7 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { } // match: (Div16u x (Const16 [c])) // cond: umagicOK(16, c) && config.RegSize == 4 && c&1 == 0 - // result: (Trunc32to16 (Rsh32Ux64 <config.fe.TypeUInt32()> (Mul32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [int64(1<<15+(umagic(16,c).m+1)/2)]) (Rsh32Ux64 <config.fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <config.fe.TypeUInt64()> [1]))) (Const64 <config.fe.TypeUInt64()> [16+umagic(16,c).s-2]))) + // result: (Trunc32to16 (Rsh32Ux64 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(1<<15+(umagic(16,c).m+1)/2)]) (Rsh32Ux64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [1]))) (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-2]))) for { x := v.Args[0] v_1 := v.Args[1] @@ -3700,21 +3702,21 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { break } v.reset(OpTrunc32to16) - v0 := b.NewValue0(v.Pos, OpRsh32Ux64, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpMul32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v2.AuxInt = int64(1<<15 + (umagic(16, c).m+1)/2) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpRsh32Ux64, config.fe.TypeUInt32()) - v4 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32()) + v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v4.AddArg(x) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 1 v3.AddArg(v5) v1.AddArg(v3) v0.AddArg(v1) - v6 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v6.AuxInt = 16 + umagic(16, c).s - 2 v0.AddArg(v6) v.AddArg(v0) @@ -3722,7 +3724,7 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { } // match: (Div16u x (Const16 [c])) // cond: umagicOK(16, c) && config.RegSize == 4 - // result: (Trunc32to16 (Rsh32Ux64 <config.fe.TypeUInt32()> (Avg32u (Lsh32x64 <config.fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <config.fe.TypeUInt64()> [16])) (Mul32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [int64(umagic(16,c).m)]) (ZeroExt16to32 x))) (Const64 <config.fe.TypeUInt64()> [16+umagic(16,c).s-1]))) + // result: (Trunc32to16 (Rsh32Ux64 <fe.TypeUInt32()> (Avg32u (Lsh32x64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [16])) (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(umagic(16,c).m)]) (ZeroExt16to32 x))) (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1]))) for { x := v.Args[0] v_1 := v.Args[1] @@ -3734,26 +3736,26 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { break } v.reset(OpTrunc32to16) - v0 := b.NewValue0(v.Pos, OpRsh32Ux64, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpAvg32u, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpLsh32x64, config.fe.TypeUInt32()) - v3 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpAvg32u, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpLsh32x64, fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 16 v2.AddArg(v4) v1.AddArg(v2) - v5 := b.NewValue0(v.Pos, OpMul32, config.fe.TypeUInt32()) - v6 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32()) + v6 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v6.AuxInt = int64(umagic(16, c).m) v5.AddArg(v6) - v7 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32()) + v7 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32()) v7.AddArg(x) v5.AddArg(v7) v1.AddArg(v5) v0.AddArg(v1) - v8 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v8 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v8.AuxInt = 16 + umagic(16, c).s - 1 v0.AddArg(v8) v.AddArg(v0) @@ -3761,9 +3763,13 @@ func rewriteValuegeneric_OpDiv16u(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpDiv32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32 (Const32 [c]) (Const32 [d])) // cond: d != 0 // result: (Const32 [int64(int32(c)/int32(d))]) @@ -3810,7 +3816,7 @@ func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { } // match: (Div32 <t> x (Const32 [-1<<31])) // cond: - // result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <config.fe.TypeUInt64()> [31])) + // result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <fe.TypeUInt64()> [31])) for { t := v.Type x := v.Args[0] @@ -3828,14 +3834,14 @@ func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 31 v.AddArg(v2) return true } // match: (Div32 <t> n (Const32 [c])) // cond: isPowerOfTwo(c) - // result: (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <config.fe.TypeUInt64()> [31])) (Const64 <config.fe.TypeUInt64()> [32-log2(c)]))) (Const64 <config.fe.TypeUInt64()> [log2(c)])) + // result: (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <fe.TypeUInt64()> [31])) (Const64 <fe.TypeUInt64()> [32-log2(c)]))) (Const64 <fe.TypeUInt64()> [log2(c)])) for { t := v.Type n := v.Args[0] @@ -3853,23 +3859,23 @@ func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpRsh32Ux64, t) v2 := b.NewValue0(v.Pos, OpRsh32x64, t) v2.AddArg(n) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = 31 v2.AddArg(v3) v1.AddArg(v2) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 32 - log2(c) v1.AddArg(v4) v0.AddArg(v1) v.AddArg(v0) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = log2(c) v.AddArg(v5) return true } // match: (Div32 <t> x (Const32 [c])) // cond: smagicOK(32,c) && config.RegSize == 8 - // result: (Sub32 <t> (Rsh64x64 <t> (Mul64 <config.fe.TypeUInt64()> (Const64 <config.fe.TypeUInt64()> [int64(smagic(32,c).m)]) (SignExt32to64 x)) (Const64 <config.fe.TypeUInt64()> [32+smagic(32,c).s])) (Rsh64x64 <t> (SignExt32to64 x) (Const64 <config.fe.TypeUInt64()> [63]))) + // result: (Sub32 <t> (Rsh64x64 <t> (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(smagic(32,c).m)]) (SignExt32to64 x)) (Const64 <fe.TypeUInt64()> [32+smagic(32,c).s])) (Rsh64x64 <t> (SignExt32to64 x) (Const64 <fe.TypeUInt64()> [63]))) for { t := v.Type x := v.Args[0] @@ -3884,23 +3890,23 @@ func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { v.reset(OpSub32) v.Type = t v0 := b.NewValue0(v.Pos, OpRsh64x64, t) - v1 := b.NewValue0(v.Pos, OpMul64, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = int64(smagic(32, c).m) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v3 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v3.AddArg(x) v1.AddArg(v3) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 32 + smagic(32, c).s v0.AddArg(v4) v.AddArg(v0) v5 := b.NewValue0(v.Pos, OpRsh64x64, t) - v6 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64()) + v6 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64()) v6.AddArg(x) v5.AddArg(v6) - v7 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v7 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v7.AuxInt = 63 v5.AddArg(v7) v.AddArg(v5) @@ -3908,7 +3914,7 @@ func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { } // match: (Div32 <t> x (Const32 [c])) // cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 - // result: (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> (Const32 <config.fe.TypeUInt32()> [int64(int32(smagic(32,c).m/2))]) x) (Const64 <config.fe.TypeUInt64()> [smagic(32,c).s-1])) (Rsh32x64 <t> x (Const64 <config.fe.TypeUInt64()> [31]))) + // result: (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> (Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m/2))]) x) (Const64 <fe.TypeUInt64()> [smagic(32,c).s-1])) (Rsh32x64 <t> x (Const64 <fe.TypeUInt64()> [31]))) for { t := v.Type x := v.Args[0] @@ -3924,18 +3930,18 @@ func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { v.Type = t v0 := b.NewValue0(v.Pos, OpRsh32x64, t) v1 := b.NewValue0(v.Pos, OpHmul32, t) - v2 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v2.AuxInt = int64(int32(smagic(32, c).m / 2)) v1.AddArg(v2) v1.AddArg(x) v0.AddArg(v1) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = smagic(32, c).s - 1 v0.AddArg(v3) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpRsh32x64, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 31 v4.AddArg(v5) v.AddArg(v4) @@ -3943,7 +3949,7 @@ func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { } // match: (Div32 <t> x (Const32 [c])) // cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 - // result: (Sub32 <t> (Rsh32x64 <t> (Add32 <t> (Hmul32 <t> (Const32 <config.fe.TypeUInt32()> [int64(int32(smagic(32,c).m))]) x) x) (Const64 <config.fe.TypeUInt64()> [smagic(32,c).s])) (Rsh32x64 <t> x (Const64 <config.fe.TypeUInt64()> [31]))) + // result: (Sub32 <t> (Rsh32x64 <t> (Add32 <t> (Hmul32 <t> (Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m))]) x) x) (Const64 <fe.TypeUInt64()> [smagic(32,c).s])) (Rsh32x64 <t> x (Const64 <fe.TypeUInt64()> [31]))) for { t := v.Type x := v.Args[0] @@ -3960,20 +3966,20 @@ func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { v0 := b.NewValue0(v.Pos, OpRsh32x64, t) v1 := b.NewValue0(v.Pos, OpAdd32, t) v2 := b.NewValue0(v.Pos, OpHmul32, t) - v3 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v3.AuxInt = int64(int32(smagic(32, c).m)) v2.AddArg(v3) v2.AddArg(x) v1.AddArg(v2) v1.AddArg(x) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = smagic(32, c).s v0.AddArg(v4) v.AddArg(v0) v5 := b.NewValue0(v.Pos, OpRsh32x64, t) v5.AddArg(x) - v6 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v6.AuxInt = 31 v5.AddArg(v6) v.AddArg(v5) @@ -3981,9 +3987,7 @@ func rewriteValuegeneric_OpDiv32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpDiv32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpDiv32F(v *Value) bool { // match: (Div32F (Const32F [c]) (Const32F [d])) // cond: // result: (Const32F [f2i(float64(i2f32(c) / i2f32(d)))]) @@ -4037,9 +4041,13 @@ func rewriteValuegeneric_OpDiv32F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { +func rewriteValuegeneric_OpDiv32u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div32u (Const32 [c]) (Const32 [d])) // cond: d != 0 // result: (Const32 [int64(int32(uint32(c)/uint32(d)))]) @@ -4063,7 +4071,7 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { } // match: (Div32u n (Const32 [c])) // cond: isPowerOfTwo(c&0xffffffff) - // result: (Rsh32Ux64 n (Const64 <config.fe.TypeUInt64()> [log2(c&0xffffffff)])) + // result: (Rsh32Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffffffff)])) for { n := v.Args[0] v_1 := v.Args[1] @@ -4076,14 +4084,14 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { } v.reset(OpRsh32Ux64) v.AddArg(n) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = log2(c & 0xffffffff) v.AddArg(v0) return true } // match: (Div32u x (Const32 [c])) // cond: umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 - // result: (Rsh32Ux64 <config.fe.TypeUInt32()> (Hmul32u <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [int64(int32(1<<31+umagic(32,c).m/2))]) x) (Const64 <config.fe.TypeUInt64()> [umagic(32,c).s-1])) + // result: (Rsh32Ux64 <fe.TypeUInt32()> (Hmul32u <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(int32(1<<31+umagic(32,c).m/2))]) x) (Const64 <fe.TypeUInt64()> [umagic(32,c).s-1])) for { x := v.Args[0] v_1 := v.Args[1] @@ -4095,21 +4103,21 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { break } v.reset(OpRsh32Ux64) - v.Type = config.fe.TypeUInt32() - v0 := b.NewValue0(v.Pos, OpHmul32u, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v.Type = fe.TypeUInt32() + v0 := b.NewValue0(v.Pos, OpHmul32u, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v1.AuxInt = int64(int32(1<<31 + umagic(32, c).m/2)) v0.AddArg(v1) v0.AddArg(x) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = umagic(32, c).s - 1 v.AddArg(v2) return true } // match: (Div32u x (Const32 [c])) // cond: umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 - // result: (Rsh32Ux64 <config.fe.TypeUInt32()> (Hmul32u <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) (Rsh32Ux64 <config.fe.TypeUInt32()> x (Const64 <config.fe.TypeUInt64()> [1]))) (Const64 <config.fe.TypeUInt64()> [umagic(32,c).s-2])) + // result: (Rsh32Ux64 <fe.TypeUInt32()> (Hmul32u <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) (Rsh32Ux64 <fe.TypeUInt32()> x (Const64 <fe.TypeUInt64()> [1]))) (Const64 <fe.TypeUInt64()> [umagic(32,c).s-2])) for { x := v.Args[0] v_1 := v.Args[1] @@ -4121,26 +4129,26 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { break } v.reset(OpRsh32Ux64) - v.Type = config.fe.TypeUInt32() - v0 := b.NewValue0(v.Pos, OpHmul32u, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v.Type = fe.TypeUInt32() + v0 := b.NewValue0(v.Pos, OpHmul32u, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v1.AuxInt = int64(int32(1<<31 + (umagic(32, c).m+1)/2)) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpRsh32Ux64, config.fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32()) v2.AddArg(x) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = 1 v2.AddArg(v3) v0.AddArg(v2) v.AddArg(v0) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = umagic(32, c).s - 2 v.AddArg(v4) return true } // match: (Div32u x (Const32 [c])) // cond: umagicOK(32, c) && config.RegSize == 4 - // result: (Rsh32Ux64 <config.fe.TypeUInt32()> (Avg32u x (Hmul32u <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [int64(int32(umagic(32,c).m))]) x)) (Const64 <config.fe.TypeUInt64()> [umagic(32,c).s-1])) + // result: (Rsh32Ux64 <fe.TypeUInt32()> (Avg32u x (Hmul32u <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(int32(umagic(32,c).m))]) x)) (Const64 <fe.TypeUInt64()> [umagic(32,c).s-1])) for { x := v.Args[0] v_1 := v.Args[1] @@ -4152,24 +4160,24 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { break } v.reset(OpRsh32Ux64) - v.Type = config.fe.TypeUInt32() - v0 := b.NewValue0(v.Pos, OpAvg32u, config.fe.TypeUInt32()) + v.Type = fe.TypeUInt32() + v0 := b.NewValue0(v.Pos, OpAvg32u, fe.TypeUInt32()) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpHmul32u, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpHmul32u, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v2.AuxInt = int64(int32(umagic(32, c).m)) v1.AddArg(v2) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = umagic(32, c).s - 1 v.AddArg(v3) return true } // match: (Div32u x (Const32 [c])) // cond: umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0 - // result: (Trunc64to32 (Rsh64Ux64 <config.fe.TypeUInt64()> (Mul64 <config.fe.TypeUInt64()> (Const64 <config.fe.TypeUInt64()> [int64(1<<31+umagic(32,c).m/2)]) (ZeroExt32to64 x)) (Const64 <config.fe.TypeUInt64()> [32+umagic(32,c).s-1]))) + // result: (Trunc64to32 (Rsh64Ux64 <fe.TypeUInt64()> (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<31+umagic(32,c).m/2)]) (ZeroExt32to64 x)) (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1]))) for { x := v.Args[0] v_1 := v.Args[1] @@ -4181,16 +4189,16 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { break } v.reset(OpTrunc64to32) - v0 := b.NewValue0(v.Pos, OpRsh64Ux64, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpMul64, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = int64(1<<31 + umagic(32, c).m/2) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(x) v1.AddArg(v3) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 32 + umagic(32, c).s - 1 v0.AddArg(v4) v.AddArg(v0) @@ -4198,7 +4206,7 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { } // match: (Div32u x (Const32 [c])) // cond: umagicOK(32, c) && config.RegSize == 8 && c&1 == 0 - // result: (Trunc64to32 (Rsh64Ux64 <config.fe.TypeUInt64()> (Mul64 <config.fe.TypeUInt64()> (Const64 <config.fe.TypeUInt64()> [int64(1<<31+(umagic(32,c).m+1)/2)]) (Rsh64Ux64 <config.fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <config.fe.TypeUInt64()> [1]))) (Const64 <config.fe.TypeUInt64()> [32+umagic(32,c).s-2]))) + // result: (Trunc64to32 (Rsh64Ux64 <fe.TypeUInt64()> (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<31+(umagic(32,c).m+1)/2)]) (Rsh64Ux64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [1]))) (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-2]))) for { x := v.Args[0] v_1 := v.Args[1] @@ -4210,21 +4218,21 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { break } v.reset(OpTrunc64to32) - v0 := b.NewValue0(v.Pos, OpRsh64Ux64, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpMul64, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = int64(1<<31 + (umagic(32, c).m+1)/2) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpRsh64Ux64, config.fe.TypeUInt64()) - v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v4.AddArg(x) v3.AddArg(v4) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 1 v3.AddArg(v5) v1.AddArg(v3) v0.AddArg(v1) - v6 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v6.AuxInt = 32 + umagic(32, c).s - 2 v0.AddArg(v6) v.AddArg(v0) @@ -4232,7 +4240,7 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { } // match: (Div32u x (Const32 [c])) // cond: umagicOK(32, c) && config.RegSize == 8 - // result: (Trunc64to32 (Rsh64Ux64 <config.fe.TypeUInt64()> (Avg64u (Lsh64x64 <config.fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <config.fe.TypeUInt64()> [32])) (Mul64 <config.fe.TypeUInt64()> (Const64 <config.fe.TypeUInt32()> [int64(umagic(32,c).m)]) (ZeroExt32to64 x))) (Const64 <config.fe.TypeUInt64()> [32+umagic(32,c).s-1]))) + // result: (Trunc64to32 (Rsh64Ux64 <fe.TypeUInt64()> (Avg64u (Lsh64x64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [32])) (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt32()> [int64(umagic(32,c).m)]) (ZeroExt32to64 x))) (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1]))) for { x := v.Args[0] v_1 := v.Args[1] @@ -4244,26 +4252,26 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { break } v.reset(OpTrunc64to32) - v0 := b.NewValue0(v.Pos, OpRsh64Ux64, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpAvg64u, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpLsh64x64, config.fe.TypeUInt64()) - v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpAvg64u, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpLsh64x64, fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v3.AddArg(x) v2.AddArg(v3) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 32 v2.AddArg(v4) v1.AddArg(v2) - v5 := b.NewValue0(v.Pos, OpMul64, config.fe.TypeUInt64()) - v6 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt32()) + v5 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt32()) v6.AuxInt = int64(umagic(32, c).m) v5.AddArg(v6) - v7 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64()) + v7 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64()) v7.AddArg(x) v5.AddArg(v7) v1.AddArg(v5) v0.AddArg(v1) - v8 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v8 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v8.AuxInt = 32 + umagic(32, c).s - 1 v0.AddArg(v8) v.AddArg(v0) @@ -4271,9 +4279,13 @@ func rewriteValuegeneric_OpDiv32u(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpDiv64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div64 (Const64 [c]) (Const64 [d])) // cond: d != 0 // result: (Const64 [c/d]) @@ -4320,7 +4332,7 @@ func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool { } // match: (Div64 <t> x (Const64 [-1<<63])) // cond: - // result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <config.fe.TypeUInt64()> [63])) + // result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <fe.TypeUInt64()> [63])) for { t := v.Type x := v.Args[0] @@ -4338,14 +4350,14 @@ func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool { v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 63 v.AddArg(v2) return true } // match: (Div64 <t> n (Const64 [c])) // cond: isPowerOfTwo(c) - // result: (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <config.fe.TypeUInt64()> [63])) (Const64 <config.fe.TypeUInt64()> [64-log2(c)]))) (Const64 <config.fe.TypeUInt64()> [log2(c)])) + // result: (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <fe.TypeUInt64()> [63])) (Const64 <fe.TypeUInt64()> [64-log2(c)]))) (Const64 <fe.TypeUInt64()> [log2(c)])) for { t := v.Type n := v.Args[0] @@ -4363,23 +4375,23 @@ func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpRsh64Ux64, t) v2 := b.NewValue0(v.Pos, OpRsh64x64, t) v2.AddArg(n) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = 63 v2.AddArg(v3) v1.AddArg(v2) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 64 - log2(c) v1.AddArg(v4) v0.AddArg(v1) v.AddArg(v0) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = log2(c) v.AddArg(v5) return true } // match: (Div64 <t> x (Const64 [c])) // cond: smagicOK(64,c) && smagic(64,c).m&1 == 0 - // result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <config.fe.TypeUInt64()> [int64(smagic(64,c).m/2)]) x) (Const64 <config.fe.TypeUInt64()> [smagic(64,c).s-1])) (Rsh64x64 <t> x (Const64 <config.fe.TypeUInt64()> [63]))) + // result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m/2)]) x) (Const64 <fe.TypeUInt64()> [smagic(64,c).s-1])) (Rsh64x64 <t> x (Const64 <fe.TypeUInt64()> [63]))) for { t := v.Type x := v.Args[0] @@ -4395,18 +4407,18 @@ func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool { v.Type = t v0 := b.NewValue0(v.Pos, OpRsh64x64, t) v1 := b.NewValue0(v.Pos, OpHmul64, t) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = int64(smagic(64, c).m / 2) v1.AddArg(v2) v1.AddArg(x) v0.AddArg(v1) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = smagic(64, c).s - 1 v0.AddArg(v3) v.AddArg(v0) v4 := b.NewValue0(v.Pos, OpRsh64x64, t) v4.AddArg(x) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = 63 v4.AddArg(v5) v.AddArg(v4) @@ -4414,7 +4426,7 @@ func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool { } // match: (Div64 <t> x (Const64 [c])) // cond: smagicOK(64,c) && smagic(64,c).m&1 != 0 - // result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <config.fe.TypeUInt64()> [int64(smagic(64,c).m)]) x) x) (Const64 <config.fe.TypeUInt64()> [smagic(64,c).s])) (Rsh64x64 <t> x (Const64 <config.fe.TypeUInt64()> [63]))) + // result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m)]) x) x) (Const64 <fe.TypeUInt64()> [smagic(64,c).s])) (Rsh64x64 <t> x (Const64 <fe.TypeUInt64()> [63]))) for { t := v.Type x := v.Args[0] @@ -4431,20 +4443,20 @@ func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool { v0 := b.NewValue0(v.Pos, OpRsh64x64, t) v1 := b.NewValue0(v.Pos, OpAdd64, t) v2 := b.NewValue0(v.Pos, OpHmul64, t) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = int64(smagic(64, c).m) v2.AddArg(v3) v2.AddArg(x) v1.AddArg(v2) v1.AddArg(x) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = smagic(64, c).s v0.AddArg(v4) v.AddArg(v0) v5 := b.NewValue0(v.Pos, OpRsh64x64, t) v5.AddArg(x) - v6 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v6.AuxInt = 63 v5.AddArg(v6) v.AddArg(v5) @@ -4452,9 +4464,7 @@ func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpDiv64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpDiv64F(v *Value) bool { // match: (Div64F (Const64F [c]) (Const64F [d])) // cond: // result: (Const64F [f2i(i2f(c) / i2f(d))]) @@ -4508,9 +4518,13 @@ func rewriteValuegeneric_OpDiv64F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpDiv64u(v *Value, config *Config) bool { +func rewriteValuegeneric_OpDiv64u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div64u (Const64 [c]) (Const64 [d])) // cond: d != 0 // result: (Const64 [int64(uint64(c)/uint64(d))]) @@ -4534,7 +4548,7 @@ func rewriteValuegeneric_OpDiv64u(v *Value, config *Config) bool { } // match: (Div64u n (Const64 [c])) // cond: isPowerOfTwo(c) - // result: (Rsh64Ux64 n (Const64 <config.fe.TypeUInt64()> [log2(c)])) + // result: (Rsh64Ux64 n (Const64 <fe.TypeUInt64()> [log2(c)])) for { n := v.Args[0] v_1 := v.Args[1] @@ -4547,14 +4561,14 @@ func rewriteValuegeneric_OpDiv64u(v *Value, config *Config) bool { } v.reset(OpRsh64Ux64) v.AddArg(n) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = log2(c) v.AddArg(v0) return true } // match: (Div64u x (Const64 [c])) // cond: umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 - // result: (Rsh64Ux64 <config.fe.TypeUInt64()> (Hmul64u <config.fe.TypeUInt64()> (Const64 <config.fe.TypeUInt64()> [int64(1<<63+umagic(64,c).m/2)]) x) (Const64 <config.fe.TypeUInt64()> [umagic(64,c).s-1])) + // result: (Rsh64Ux64 <fe.TypeUInt64()> (Hmul64u <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<63+umagic(64,c).m/2)]) x) (Const64 <fe.TypeUInt64()> [umagic(64,c).s-1])) for { x := v.Args[0] v_1 := v.Args[1] @@ -4566,21 +4580,21 @@ func rewriteValuegeneric_OpDiv64u(v *Value, config *Config) bool { break } v.reset(OpRsh64Ux64) - v.Type = config.fe.TypeUInt64() - v0 := b.NewValue0(v.Pos, OpHmul64u, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v.Type = fe.TypeUInt64() + v0 := b.NewValue0(v.Pos, OpHmul64u, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v1.AuxInt = int64(1<<63 + umagic(64, c).m/2) v0.AddArg(v1) v0.AddArg(x) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = umagic(64, c).s - 1 v.AddArg(v2) return true } // match: (Div64u x (Const64 [c])) // cond: umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 - // result: (Rsh64Ux64 <config.fe.TypeUInt64()> (Hmul64u <config.fe.TypeUInt64()> (Const64 <config.fe.TypeUInt64()> [int64(1<<63+(umagic(64,c).m+1)/2)]) (Rsh64Ux64 <config.fe.TypeUInt64()> x (Const64 <config.fe.TypeUInt64()> [1]))) (Const64 <config.fe.TypeUInt64()> [umagic(64,c).s-2])) + // result: (Rsh64Ux64 <fe.TypeUInt64()> (Hmul64u <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<63+(umagic(64,c).m+1)/2)]) (Rsh64Ux64 <fe.TypeUInt64()> x (Const64 <fe.TypeUInt64()> [1]))) (Const64 <fe.TypeUInt64()> [umagic(64,c).s-2])) for { x := v.Args[0] v_1 := v.Args[1] @@ -4592,26 +4606,26 @@ func rewriteValuegeneric_OpDiv64u(v *Value, config *Config) bool { break } v.reset(OpRsh64Ux64) - v.Type = config.fe.TypeUInt64() - v0 := b.NewValue0(v.Pos, OpHmul64u, config.fe.TypeUInt64()) - v1 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v.Type = fe.TypeUInt64() + v0 := b.NewValue0(v.Pos, OpHmul64u, fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v1.AuxInt = int64(1<<63 + (umagic(64, c).m+1)/2) v0.AddArg(v1) - v2 := b.NewValue0(v.Pos, OpRsh64Ux64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64()) v2.AddArg(x) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = 1 v2.AddArg(v3) v0.AddArg(v2) v.AddArg(v0) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = umagic(64, c).s - 2 v.AddArg(v4) return true } // match: (Div64u x (Const64 [c])) // cond: umagicOK(64, c) && config.RegSize == 8 - // result: (Rsh64Ux64 <config.fe.TypeUInt64()> (Avg64u x (Hmul64u <config.fe.TypeUInt64()> (Const64 <config.fe.TypeUInt64()> [int64(umagic(64,c).m)]) x)) (Const64 <config.fe.TypeUInt64()> [umagic(64,c).s-1])) + // result: (Rsh64Ux64 <fe.TypeUInt64()> (Avg64u x (Hmul64u <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(umagic(64,c).m)]) x)) (Const64 <fe.TypeUInt64()> [umagic(64,c).s-1])) for { x := v.Args[0] v_1 := v.Args[1] @@ -4623,26 +4637,30 @@ func rewriteValuegeneric_OpDiv64u(v *Value, config *Config) bool { break } v.reset(OpRsh64Ux64) - v.Type = config.fe.TypeUInt64() - v0 := b.NewValue0(v.Pos, OpAvg64u, config.fe.TypeUInt64()) + v.Type = fe.TypeUInt64() + v0 := b.NewValue0(v.Pos, OpAvg64u, fe.TypeUInt64()) v0.AddArg(x) - v1 := b.NewValue0(v.Pos, OpHmul64u, config.fe.TypeUInt64()) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpHmul64u, fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = int64(umagic(64, c).m) v1.AddArg(v2) v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = umagic(64, c).s - 1 v.AddArg(v3) return true } return false } -func rewriteValuegeneric_OpDiv8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpDiv8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8 (Const8 [c]) (Const8 [d])) // cond: d != 0 // result: (Const8 [int64(int8(c)/int8(d))]) @@ -4689,7 +4707,7 @@ func rewriteValuegeneric_OpDiv8(v *Value, config *Config) bool { } // match: (Div8 <t> x (Const8 [-1<<7 ])) // cond: - // result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <config.fe.TypeUInt64()> [7 ])) + // result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <fe.TypeUInt64()> [7 ])) for { t := v.Type x := v.Args[0] @@ -4707,14 +4725,14 @@ func rewriteValuegeneric_OpDiv8(v *Value, config *Config) bool { v1.AddArg(x) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v2.AuxInt = 7 v.AddArg(v2) return true } // match: (Div8 <t> n (Const8 [c])) // cond: isPowerOfTwo(c) - // result: (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <config.fe.TypeUInt64()> [ 7])) (Const64 <config.fe.TypeUInt64()> [ 8-log2(c)]))) (Const64 <config.fe.TypeUInt64()> [log2(c)])) + // result: (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <fe.TypeUInt64()> [ 7])) (Const64 <fe.TypeUInt64()> [ 8-log2(c)]))) (Const64 <fe.TypeUInt64()> [log2(c)])) for { t := v.Type n := v.Args[0] @@ -4732,23 +4750,23 @@ func rewriteValuegeneric_OpDiv8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Pos, OpRsh8Ux64, t) v2 := b.NewValue0(v.Pos, OpRsh8x64, t) v2.AddArg(n) - v3 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v3.AuxInt = 7 v2.AddArg(v3) v1.AddArg(v2) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 8 - log2(c) v1.AddArg(v4) v0.AddArg(v1) v.AddArg(v0) - v5 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v5.AuxInt = log2(c) v.AddArg(v5) return true } // match: (Div8 <t> x (Const8 [c])) // cond: smagicOK(8,c) - // result: (Sub8 <t> (Rsh32x64 <t> (Mul32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [int64(smagic(8,c).m)]) (SignExt8to32 x)) (Const64 <config.fe.TypeUInt64()> [8+smagic(8,c).s])) (Rsh32x64 <t> (SignExt8to32 x) (Const64 <config.fe.TypeUInt64()> [31]))) + // result: (Sub8 <t> (Rsh32x64 <t> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(smagic(8,c).m)]) (SignExt8to32 x)) (Const64 <fe.TypeUInt64()> [8+smagic(8,c).s])) (Rsh32x64 <t> (SignExt8to32 x) (Const64 <fe.TypeUInt64()> [31]))) for { t := v.Type x := v.Args[0] @@ -4763,23 +4781,23 @@ func rewriteValuegeneric_OpDiv8(v *Value, config *Config) bool { v.reset(OpSub8) v.Type = t v0 := b.NewValue0(v.Pos, OpRsh32x64, t) - v1 := b.NewValue0(v.Pos, OpMul32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v2.AuxInt = int64(smagic(8, c).m) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v3 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v3.AddArg(x) v1.AddArg(v3) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 8 + smagic(8, c).s v0.AddArg(v4) v.AddArg(v0) v5 := b.NewValue0(v.Pos, OpRsh32x64, t) - v6 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32()) + v6 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32()) v6.AddArg(x) v5.AddArg(v6) - v7 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v7 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v7.AuxInt = 31 v5.AddArg(v7) v.AddArg(v5) @@ -4787,9 +4805,13 @@ func rewriteValuegeneric_OpDiv8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpDiv8u(v *Value, config *Config) bool { +func rewriteValuegeneric_OpDiv8u(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Div8u (Const8 [c]) (Const8 [d])) // cond: d != 0 // result: (Const8 [int64(int8(uint8(c)/uint8(d)))]) @@ -4813,7 +4835,7 @@ func rewriteValuegeneric_OpDiv8u(v *Value, config *Config) bool { } // match: (Div8u n (Const8 [c])) // cond: isPowerOfTwo(c&0xff) - // result: (Rsh8Ux64 n (Const64 <config.fe.TypeUInt64()> [log2(c&0xff)])) + // result: (Rsh8Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xff)])) for { n := v.Args[0] v_1 := v.Args[1] @@ -4826,14 +4848,14 @@ func rewriteValuegeneric_OpDiv8u(v *Value, config *Config) bool { } v.reset(OpRsh8Ux64) v.AddArg(n) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = log2(c & 0xff) v.AddArg(v0) return true } // match: (Div8u x (Const8 [c])) // cond: umagicOK(8, c) - // result: (Trunc32to8 (Rsh32Ux64 <config.fe.TypeUInt32()> (Mul32 <config.fe.TypeUInt32()> (Const32 <config.fe.TypeUInt32()> [int64(1<<8+umagic(8,c).m)]) (ZeroExt8to32 x)) (Const64 <config.fe.TypeUInt64()> [8+umagic(8,c).s]))) + // result: (Trunc32to8 (Rsh32Ux64 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(1<<8+umagic(8,c).m)]) (ZeroExt8to32 x)) (Const64 <fe.TypeUInt64()> [8+umagic(8,c).s]))) for { x := v.Args[0] v_1 := v.Args[1] @@ -4845,16 +4867,16 @@ func rewriteValuegeneric_OpDiv8u(v *Value, config *Config) bool { break } v.reset(OpTrunc32to8) - v0 := b.NewValue0(v.Pos, OpRsh32Ux64, config.fe.TypeUInt32()) - v1 := b.NewValue0(v.Pos, OpMul32, config.fe.TypeUInt32()) - v2 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32()) + v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32()) + v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32()) v2.AuxInt = int64(1<<8 + umagic(8, c).m) v1.AddArg(v2) - v3 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32()) + v3 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32()) v3.AddArg(x) v1.AddArg(v3) v0.AddArg(v1) - v4 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v4.AuxInt = 8 + umagic(8, c).s v0.AddArg(v4) v.AddArg(v0) @@ -4862,7 +4884,7 @@ func rewriteValuegeneric_OpDiv8u(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpEq16(v *Value) bool { b := v.Block _ = b // match: (Eq16 x x) @@ -4948,7 +4970,7 @@ func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpEq32(v *Value) bool { b := v.Block _ = b // match: (Eq32 x x) @@ -5034,7 +5056,7 @@ func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpEq64(v *Value) bool { b := v.Block _ = b // match: (Eq64 x x) @@ -5120,7 +5142,7 @@ func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpEq8(v *Value) bool { b := v.Block _ = b // match: (Eq8 x x) @@ -5206,9 +5228,7 @@ func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpEqB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpEqB(v *Value) bool { // match: (EqB (ConstBool [c]) (ConstBool [d])) // cond: // result: (ConstBool [b2i(c == d)]) @@ -5262,9 +5282,13 @@ func rewriteValuegeneric_OpEqB(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool { +func rewriteValuegeneric_OpEqInter(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqInter x y) // cond: // result: (EqPtr (ITab x) (ITab y)) @@ -5272,18 +5296,22 @@ func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpEqPtr) - v0 := b.NewValue0(v.Pos, OpITab, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpITab, fe.TypeBytePtr()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpITab, config.fe.TypeBytePtr()) + v1 := b.NewValue0(v.Pos, OpITab, fe.TypeBytePtr()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { +func rewriteValuegeneric_OpEqPtr(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqPtr p (ConstNil)) // cond: // result: (Not (IsNonNil p)) @@ -5294,7 +5322,7 @@ func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { break } v.reset(OpNot) - v0 := b.NewValue0(v.Pos, OpIsNonNil, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpIsNonNil, fe.TypeBool()) v0.AddArg(p) v.AddArg(v0) return true @@ -5309,16 +5337,20 @@ func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { } p := v.Args[1] v.reset(OpNot) - v0 := b.NewValue0(v.Pos, OpIsNonNil, config.fe.TypeBool()) + v0 := b.NewValue0(v.Pos, OpIsNonNil, fe.TypeBool()) v0.AddArg(p) v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool { +func rewriteValuegeneric_OpEqSlice(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (EqSlice x y) // cond: // result: (EqPtr (SlicePtr x) (SlicePtr y)) @@ -5326,18 +5358,16 @@ func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpEqPtr) - v0 := b.NewValue0(v.Pos, OpSlicePtr, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpSlicePtr, fe.TypeBytePtr()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSlicePtr, config.fe.TypeBytePtr()) + v1 := b.NewValue0(v.Pos, OpSlicePtr, fe.TypeBytePtr()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuegeneric_OpGeq16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGeq16(v *Value) bool { // match: (Geq16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(c >= d)]) @@ -5358,9 +5388,7 @@ func rewriteValuegeneric_OpGeq16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGeq16U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGeq16U(v *Value) bool { // match: (Geq16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) >= uint16(d))]) @@ -5381,9 +5409,7 @@ func rewriteValuegeneric_OpGeq16U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGeq32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGeq32(v *Value) bool { // match: (Geq32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(c >= d)]) @@ -5404,9 +5430,7 @@ func rewriteValuegeneric_OpGeq32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGeq32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGeq32U(v *Value) bool { // match: (Geq32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) >= uint32(d))]) @@ -5427,9 +5451,7 @@ func rewriteValuegeneric_OpGeq32U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGeq64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGeq64(v *Value) bool { // match: (Geq64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(c >= d)]) @@ -5450,9 +5472,7 @@ func rewriteValuegeneric_OpGeq64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGeq64U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGeq64U(v *Value) bool { // match: (Geq64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) >= uint64(d))]) @@ -5473,9 +5493,7 @@ func rewriteValuegeneric_OpGeq64U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGeq8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGeq8(v *Value) bool { // match: (Geq8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(c >= d)]) @@ -5496,9 +5514,7 @@ func rewriteValuegeneric_OpGeq8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGeq8U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGeq8U(v *Value) bool { // match: (Geq8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) >= uint8(d))]) @@ -5519,9 +5535,7 @@ func rewriteValuegeneric_OpGeq8U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGreater16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGreater16(v *Value) bool { // match: (Greater16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(c > d)]) @@ -5542,9 +5556,7 @@ func rewriteValuegeneric_OpGreater16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGreater16U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGreater16U(v *Value) bool { // match: (Greater16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) > uint16(d))]) @@ -5565,9 +5577,7 @@ func rewriteValuegeneric_OpGreater16U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGreater32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGreater32(v *Value) bool { // match: (Greater32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(c > d)]) @@ -5588,9 +5598,7 @@ func rewriteValuegeneric_OpGreater32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGreater32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGreater32U(v *Value) bool { // match: (Greater32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) > uint32(d))]) @@ -5611,9 +5619,7 @@ func rewriteValuegeneric_OpGreater32U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGreater64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGreater64(v *Value) bool { // match: (Greater64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(c > d)]) @@ -5634,9 +5640,7 @@ func rewriteValuegeneric_OpGreater64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGreater64U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGreater64U(v *Value) bool { // match: (Greater64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) > uint64(d))]) @@ -5657,9 +5661,7 @@ func rewriteValuegeneric_OpGreater64U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGreater8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGreater8(v *Value) bool { // match: (Greater8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(c > d)]) @@ -5680,9 +5682,7 @@ func rewriteValuegeneric_OpGreater8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpGreater8U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpGreater8U(v *Value) bool { // match: (Greater8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) > uint8(d))]) @@ -5703,9 +5703,7 @@ func rewriteValuegeneric_OpGreater8U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpIMake(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpIMake(v *Value) bool { // match: (IMake typ (StructMake1 val)) // cond: // result: (IMake typ val) @@ -5738,9 +5736,7 @@ func rewriteValuegeneric_OpIMake(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpInterCall(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpInterCall(v *Value) bool { // match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem) // cond: devirt(v, itab, off) != nil // result: (StaticCall [argsize] {devirt(v, itab, off)} mem) @@ -5784,9 +5780,7 @@ func rewriteValuegeneric_OpInterCall(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpIsInBounds(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpIsInBounds(v *Value) bool { // match: (IsInBounds (ZeroExt8to32 _) (Const32 [c])) // cond: (1 << 8) <= c // result: (ConstBool [1]) @@ -6223,9 +6217,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpIsNonNil(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpIsNonNil(v *Value) bool { // match: (IsNonNil (ConstNil)) // cond: // result: (ConstBool [0]) @@ -6240,9 +6232,7 @@ func rewriteValuegeneric_OpIsNonNil(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpIsSliceInBounds(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool { // match: (IsSliceInBounds x x) // cond: // result: (ConstBool [1]) @@ -6393,9 +6383,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLeq16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLeq16(v *Value) bool { // match: (Leq16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(c <= d)]) @@ -6416,9 +6404,7 @@ func rewriteValuegeneric_OpLeq16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLeq16U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLeq16U(v *Value) bool { // match: (Leq16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) <= uint16(d))]) @@ -6439,9 +6425,7 @@ func rewriteValuegeneric_OpLeq16U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLeq32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLeq32(v *Value) bool { // match: (Leq32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(c <= d)]) @@ -6462,9 +6446,7 @@ func rewriteValuegeneric_OpLeq32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLeq32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLeq32U(v *Value) bool { // match: (Leq32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) <= uint32(d))]) @@ -6485,9 +6467,7 @@ func rewriteValuegeneric_OpLeq32U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLeq64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLeq64(v *Value) bool { // match: (Leq64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(c <= d)]) @@ -6508,9 +6488,7 @@ func rewriteValuegeneric_OpLeq64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLeq64U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLeq64U(v *Value) bool { // match: (Leq64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) <= uint64(d))]) @@ -6531,9 +6509,7 @@ func rewriteValuegeneric_OpLeq64U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLeq8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLeq8(v *Value) bool { // match: (Leq8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(c <= d)]) @@ -6554,9 +6530,7 @@ func rewriteValuegeneric_OpLeq8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLeq8U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLeq8U(v *Value) bool { // match: (Leq8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) <= uint8(d))]) @@ -6577,9 +6551,7 @@ func rewriteValuegeneric_OpLeq8U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLess16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLess16(v *Value) bool { // match: (Less16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(c < d)]) @@ -6600,9 +6572,7 @@ func rewriteValuegeneric_OpLess16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLess16U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLess16U(v *Value) bool { // match: (Less16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) < uint16(d))]) @@ -6623,9 +6593,7 @@ func rewriteValuegeneric_OpLess16U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLess32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLess32(v *Value) bool { // match: (Less32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(c < d)]) @@ -6646,9 +6614,7 @@ func rewriteValuegeneric_OpLess32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLess32U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLess32U(v *Value) bool { // match: (Less32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) < uint32(d))]) @@ -6669,9 +6635,7 @@ func rewriteValuegeneric_OpLess32U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLess64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLess64(v *Value) bool { // match: (Less64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(c < d)]) @@ -6692,9 +6656,7 @@ func rewriteValuegeneric_OpLess64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLess64U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLess64U(v *Value) bool { // match: (Less64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) < uint64(d))]) @@ -6715,9 +6677,7 @@ func rewriteValuegeneric_OpLess64U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLess8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLess8(v *Value) bool { // match: (Less8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(c < d)]) @@ -6738,9 +6698,7 @@ func rewriteValuegeneric_OpLess8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLess8U(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpLess8U(v *Value) bool { // match: (Less8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) < uint8(d))]) @@ -6761,9 +6719,13 @@ func rewriteValuegeneric_OpLess8U(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLoad(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Load <t1> p1 (Store {t2} p2 x _)) // cond: isSamePtr(p1,p2) && t1.Compare(x.Type)==CMPeq && t1.Size() == t2.(Type).Size() // result: x @@ -6786,24 +6748,24 @@ func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { return true } // match: (Load <t> _ _) - // cond: t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) // result: (StructMake0) for { t := v.Type - if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) { break } v.reset(OpStructMake0) return true } // match: (Load <t> ptr mem) - // cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) // result: (StructMake1 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem)) for { t := v.Type ptr := v.Args[0] mem := v.Args[1] - if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) { break } v.reset(OpStructMake1) @@ -6817,13 +6779,13 @@ func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { return true } // match: (Load <t> ptr mem) - // cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t) // result: (StructMake2 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem)) for { t := v.Type ptr := v.Args[0] mem := v.Args[1] - if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) { break } v.reset(OpStructMake2) @@ -6844,13 +6806,13 @@ func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { return true } // match: (Load <t> ptr mem) - // cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t) // result: (StructMake3 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem)) for { t := v.Type ptr := v.Args[0] mem := v.Args[1] - if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) { break } v.reset(OpStructMake3) @@ -6878,13 +6840,13 @@ func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { return true } // match: (Load <t> ptr mem) - // cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) + // cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t) // result: (StructMake4 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem) (Load <t.FieldType(3)> (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] ptr) mem)) for { t := v.Type ptr := v.Args[0] mem := v.Args[1] - if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) { + if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) { break } v.reset(OpStructMake4) @@ -6930,13 +6892,13 @@ func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { return true } // match: (Load <t> ptr mem) - // cond: t.IsArray() && t.NumElem() == 1 && config.fe.CanSSA(t) + // cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t) // result: (ArrayMake1 (Load <t.ElemType()> ptr mem)) for { t := v.Type ptr := v.Args[0] mem := v.Args[1] - if !(t.IsArray() && t.NumElem() == 1 && config.fe.CanSSA(t)) { + if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) { break } v.reset(OpArrayMake1) @@ -6948,7 +6910,7 @@ func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh16x16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh16x16(v *Value) bool { b := v.Block _ = b // match: (Lsh16x16 <t> x (Const16 [c])) @@ -6986,7 +6948,7 @@ func rewriteValuegeneric_OpLsh16x16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh16x32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh16x32(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 <t> x (Const32 [c])) @@ -7024,9 +6986,13 @@ func rewriteValuegeneric_OpLsh16x32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh16x64 (Const16 [c]) (Const64 [d])) // cond: // result: (Const16 [int64(int16(c) << uint64(d))]) @@ -7125,7 +7091,7 @@ func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { } // match: (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - // result: (Lsh16x64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + // result: (Lsh16x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) for { v_0 := v.Args[0] if v_0.Op != OpRsh16Ux64 { @@ -7156,14 +7122,14 @@ func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { } v.reset(OpLsh16x64) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = c1 - c2 + c3 v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpLsh16x8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh16x8(v *Value) bool { b := v.Block _ = b // match: (Lsh16x8 <t> x (Const8 [c])) @@ -7201,7 +7167,7 @@ func rewriteValuegeneric_OpLsh16x8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh32x16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh32x16(v *Value) bool { b := v.Block _ = b // match: (Lsh32x16 <t> x (Const16 [c])) @@ -7239,7 +7205,7 @@ func rewriteValuegeneric_OpLsh32x16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh32x32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh32x32(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 <t> x (Const32 [c])) @@ -7277,9 +7243,13 @@ func rewriteValuegeneric_OpLsh32x32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh32x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh32x64 (Const32 [c]) (Const64 [d])) // cond: // result: (Const32 [int64(int32(c) << uint64(d))]) @@ -7378,7 +7348,7 @@ func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { } // match: (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - // result: (Lsh32x64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + // result: (Lsh32x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) for { v_0 := v.Args[0] if v_0.Op != OpRsh32Ux64 { @@ -7409,14 +7379,14 @@ func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { } v.reset(OpLsh32x64) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = c1 - c2 + c3 v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpLsh32x8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh32x8(v *Value) bool { b := v.Block _ = b // match: (Lsh32x8 <t> x (Const8 [c])) @@ -7454,7 +7424,7 @@ func rewriteValuegeneric_OpLsh32x8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh64x16(v *Value) bool { b := v.Block _ = b // match: (Lsh64x16 <t> x (Const16 [c])) @@ -7492,7 +7462,7 @@ func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh64x32(v *Value) bool { b := v.Block _ = b // match: (Lsh64x32 <t> x (Const32 [c])) @@ -7530,9 +7500,13 @@ func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh64x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh64x64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c << uint64(d)]) @@ -7631,7 +7605,7 @@ func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool { } // match: (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - // result: (Lsh64x64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + // result: (Lsh64x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) for { v_0 := v.Args[0] if v_0.Op != OpRsh64Ux64 { @@ -7662,14 +7636,14 @@ func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool { } v.reset(OpLsh64x64) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = c1 - c2 + c3 v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh64x8(v *Value) bool { b := v.Block _ = b // match: (Lsh64x8 <t> x (Const8 [c])) @@ -7707,7 +7681,7 @@ func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh8x16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh8x16(v *Value) bool { b := v.Block _ = b // match: (Lsh8x16 <t> x (Const16 [c])) @@ -7745,7 +7719,7 @@ func rewriteValuegeneric_OpLsh8x16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh8x32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh8x32(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 <t> x (Const32 [c])) @@ -7783,9 +7757,13 @@ func rewriteValuegeneric_OpLsh8x32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh8x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Lsh8x64 (Const8 [c]) (Const64 [d])) // cond: // result: (Const8 [int64(int8(c) << uint64(d))]) @@ -7884,7 +7862,7 @@ func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool { } // match: (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - // result: (Lsh8x64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + // result: (Lsh8x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) for { v_0 := v.Args[0] if v_0.Op != OpRsh8Ux64 { @@ -7915,14 +7893,14 @@ func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool { } v.reset(OpLsh8x64) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = c1 - c2 + c3 v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh8x8(v *Value) bool { b := v.Block _ = b // match: (Lsh8x8 <t> x (Const8 [c])) @@ -7960,7 +7938,7 @@ func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMod16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMod16(v *Value) bool { b := v.Block _ = b // match: (Mod16 (Const16 [c]) (Const16 [d])) @@ -8037,7 +8015,7 @@ func rewriteValuegeneric_OpMod16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMod16u(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMod16u(v *Value) bool { b := v.Block _ = b // match: (Mod16u (Const16 [c]) (Const16 [d])) @@ -8113,7 +8091,7 @@ func rewriteValuegeneric_OpMod16u(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMod32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMod32(v *Value) bool { b := v.Block _ = b // match: (Mod32 (Const32 [c]) (Const32 [d])) @@ -8190,7 +8168,7 @@ func rewriteValuegeneric_OpMod32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMod32u(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMod32u(v *Value) bool { b := v.Block _ = b // match: (Mod32u (Const32 [c]) (Const32 [d])) @@ -8266,7 +8244,7 @@ func rewriteValuegeneric_OpMod32u(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMod64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMod64(v *Value) bool { b := v.Block _ = b // match: (Mod64 (Const64 [c]) (Const64 [d])) @@ -8343,7 +8321,7 @@ func rewriteValuegeneric_OpMod64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMod64u(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMod64u(v *Value) bool { b := v.Block _ = b // match: (Mod64u (Const64 [c]) (Const64 [d])) @@ -8419,7 +8397,7 @@ func rewriteValuegeneric_OpMod64u(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMod8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMod8(v *Value) bool { b := v.Block _ = b // match: (Mod8 (Const8 [c]) (Const8 [d])) @@ -8496,7 +8474,7 @@ func rewriteValuegeneric_OpMod8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMod8u(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMod8u(v *Value) bool { b := v.Block _ = b // match: (Mod8u (Const8 [c]) (Const8 [d])) @@ -8572,9 +8550,13 @@ func rewriteValuegeneric_OpMod8u(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMul16(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mul16 (Const16 [c]) (Const16 [d])) // cond: // result: (Const16 [int64(int16(c*d))]) @@ -8628,7 +8610,7 @@ func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { } // match: (Mul16 <t> n (Const16 [c])) // cond: isPowerOfTwo(c) - // result: (Lsh16x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(c)])) + // result: (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) for { t := v.Type n := v.Args[0] @@ -8643,14 +8625,14 @@ func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { v.reset(OpLsh16x64) v.Type = t v.AddArg(n) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = log2(c) v.AddArg(v0) return true } // match: (Mul16 <t> n (Const16 [c])) // cond: t.IsSigned() && isPowerOfTwo(-c) - // result: (Neg16 (Lsh16x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(-c)]))) + // result: (Neg16 (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) for { t := v.Type n := v.Args[0] @@ -8665,7 +8647,7 @@ func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { v.reset(OpNeg16) v0 := b.NewValue0(v.Pos, OpLsh16x64, t) v0.AddArg(n) - v1 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v1.AuxInt = log2(-c) v0.AddArg(v1) v.AddArg(v0) @@ -8756,9 +8738,13 @@ func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMul32(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mul32 (Const32 [c]) (Const32 [d])) // cond: // result: (Const32 [int64(int32(c*d))]) @@ -8812,7 +8798,7 @@ func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { } // match: (Mul32 <t> n (Const32 [c])) // cond: isPowerOfTwo(c) - // result: (Lsh32x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(c)])) + // result: (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) for { t := v.Type n := v.Args[0] @@ -8827,14 +8813,14 @@ func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { v.reset(OpLsh32x64) v.Type = t v.AddArg(n) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = log2(c) v.AddArg(v0) return true } // match: (Mul32 <t> n (Const32 [c])) // cond: t.IsSigned() && isPowerOfTwo(-c) - // result: (Neg32 (Lsh32x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(-c)]))) + // result: (Neg32 (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) for { t := v.Type n := v.Args[0] @@ -8849,7 +8835,7 @@ func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { v.reset(OpNeg32) v0 := b.NewValue0(v.Pos, OpLsh32x64, t) v0.AddArg(n) - v1 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v1.AuxInt = log2(-c) v0.AddArg(v1) v.AddArg(v0) @@ -8978,9 +8964,7 @@ func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMul32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpMul32F(v *Value) bool { // match: (Mul32F (Const32F [c]) (Const32F [d])) // cond: // result: (Const32F [f2i(float64(i2f32(c) * i2f32(d)))]) @@ -9067,9 +9051,13 @@ func rewriteValuegeneric_OpMul32F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMul64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mul64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c*d]) @@ -9123,7 +9111,7 @@ func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { } // match: (Mul64 <t> n (Const64 [c])) // cond: isPowerOfTwo(c) - // result: (Lsh64x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(c)])) + // result: (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) for { t := v.Type n := v.Args[0] @@ -9138,14 +9126,14 @@ func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { v.reset(OpLsh64x64) v.Type = t v.AddArg(n) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = log2(c) v.AddArg(v0) return true } // match: (Mul64 <t> n (Const64 [c])) // cond: t.IsSigned() && isPowerOfTwo(-c) - // result: (Neg64 (Lsh64x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(-c)]))) + // result: (Neg64 (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) for { t := v.Type n := v.Args[0] @@ -9160,7 +9148,7 @@ func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { v.reset(OpNeg64) v0 := b.NewValue0(v.Pos, OpLsh64x64, t) v0.AddArg(n) - v1 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v1.AuxInt = log2(-c) v0.AddArg(v1) v.AddArg(v0) @@ -9289,9 +9277,7 @@ func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMul64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpMul64F(v *Value) bool { // match: (Mul64F (Const64F [c]) (Const64F [d])) // cond: // result: (Const64F [f2i(i2f(c) * i2f(d))]) @@ -9378,9 +9364,13 @@ func rewriteValuegeneric_OpMul64F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMul8(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Mul8 (Const8 [c]) (Const8 [d])) // cond: // result: (Const8 [int64(int8(c*d))]) @@ -9434,7 +9424,7 @@ func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { } // match: (Mul8 <t> n (Const8 [c])) // cond: isPowerOfTwo(c) - // result: (Lsh8x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(c)])) + // result: (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) for { t := v.Type n := v.Args[0] @@ -9449,14 +9439,14 @@ func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { v.reset(OpLsh8x64) v.Type = t v.AddArg(n) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = log2(c) v.AddArg(v0) return true } // match: (Mul8 <t> n (Const8 [c])) // cond: t.IsSigned() && isPowerOfTwo(-c) - // result: (Neg8 (Lsh8x64 <t> n (Const64 <config.fe.TypeUInt64()> [log2(-c)]))) + // result: (Neg8 (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) for { t := v.Type n := v.Args[0] @@ -9471,7 +9461,7 @@ func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { v.reset(OpNeg8) v0 := b.NewValue0(v.Pos, OpLsh8x64, t) v0.AddArg(n) - v1 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v1.AuxInt = log2(-c) v0.AddArg(v1) v.AddArg(v0) @@ -9562,9 +9552,7 @@ func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeg16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpNeg16(v *Value) bool { // match: (Neg16 (Const16 [c])) // cond: // result: (Const16 [int64(-int16(c))]) @@ -9595,9 +9583,7 @@ func rewriteValuegeneric_OpNeg16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeg32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpNeg32(v *Value) bool { // match: (Neg32 (Const32 [c])) // cond: // result: (Const32 [int64(-int32(c))]) @@ -9628,9 +9614,7 @@ func rewriteValuegeneric_OpNeg32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeg32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpNeg32F(v *Value) bool { // match: (Neg32F (Const32F [c])) // cond: i2f(c) != 0 // result: (Const32F [f2i(-i2f(c))]) @@ -9649,9 +9633,7 @@ func rewriteValuegeneric_OpNeg32F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeg64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpNeg64(v *Value) bool { // match: (Neg64 (Const64 [c])) // cond: // result: (Const64 [-c]) @@ -9682,9 +9664,7 @@ func rewriteValuegeneric_OpNeg64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeg64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpNeg64F(v *Value) bool { // match: (Neg64F (Const64F [c])) // cond: i2f(c) != 0 // result: (Const64F [f2i(-i2f(c))]) @@ -9703,9 +9683,7 @@ func rewriteValuegeneric_OpNeg64F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeg8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpNeg8(v *Value) bool { // match: (Neg8 (Const8 [c])) // cond: // result: (Const8 [int64( -int8(c))]) @@ -9736,7 +9714,7 @@ func rewriteValuegeneric_OpNeg8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpNeq16(v *Value) bool { b := v.Block _ = b // match: (Neq16 x x) @@ -9822,7 +9800,7 @@ func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpNeq32(v *Value) bool { b := v.Block _ = b // match: (Neq32 x x) @@ -9908,7 +9886,7 @@ func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpNeq64(v *Value) bool { b := v.Block _ = b // match: (Neq64 x x) @@ -9994,7 +9972,7 @@ func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpNeq8(v *Value) bool { b := v.Block _ = b // match: (Neq8 x x) @@ -10080,9 +10058,7 @@ func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeqB(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpNeqB(v *Value) bool { // match: (NeqB (ConstBool [c]) (ConstBool [d])) // cond: // result: (ConstBool [b2i(c != d)]) @@ -10136,9 +10112,13 @@ func rewriteValuegeneric_OpNeqB(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool { +func rewriteValuegeneric_OpNeqInter(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (NeqInter x y) // cond: // result: (NeqPtr (ITab x) (ITab y)) @@ -10146,18 +10126,16 @@ func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpNeqPtr) - v0 := b.NewValue0(v.Pos, OpITab, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpITab, fe.TypeBytePtr()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpITab, config.fe.TypeBytePtr()) + v1 := b.NewValue0(v.Pos, OpITab, fe.TypeBytePtr()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpNeqPtr(v *Value) bool { // match: (NeqPtr p (ConstNil)) // cond: // result: (IsNonNil p) @@ -10186,9 +10164,13 @@ func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool { +func rewriteValuegeneric_OpNeqSlice(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (NeqSlice x y) // cond: // result: (NeqPtr (SlicePtr x) (SlicePtr y)) @@ -10196,18 +10178,22 @@ func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool { x := v.Args[0] y := v.Args[1] v.reset(OpNeqPtr) - v0 := b.NewValue0(v.Pos, OpSlicePtr, config.fe.TypeBytePtr()) + v0 := b.NewValue0(v.Pos, OpSlicePtr, fe.TypeBytePtr()) v0.AddArg(x) v.AddArg(v0) - v1 := b.NewValue0(v.Pos, OpSlicePtr, config.fe.TypeBytePtr()) + v1 := b.NewValue0(v.Pos, OpSlicePtr, fe.TypeBytePtr()) v1.AddArg(y) v.AddArg(v1) return true } } -func rewriteValuegeneric_OpNilCheck(v *Value, config *Config) bool { +func rewriteValuegeneric_OpNilCheck(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (NilCheck (GetG mem) mem) // cond: // result: mem @@ -10226,7 +10212,7 @@ func rewriteValuegeneric_OpNilCheck(v *Value, config *Config) bool { return true } // match: (NilCheck (Load (OffPtr [c] (SP)) mem) mem) - // cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(config.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") + // cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") // result: (Invalid) for { v_0 := v.Args[0] @@ -10246,14 +10232,14 @@ func rewriteValuegeneric_OpNilCheck(v *Value, config *Config) bool { if mem != v.Args[1] { break } - if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(config.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check")) { + if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check")) { break } v.reset(OpInvalid) return true } // match: (NilCheck (OffPtr (Load (OffPtr [c] (SP)) mem)) mem) - // cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(config.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") + // cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") // result: (Invalid) for { v_0 := v.Args[0] @@ -10277,7 +10263,7 @@ func rewriteValuegeneric_OpNilCheck(v *Value, config *Config) bool { if mem != v.Args[1] { break } - if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(config.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check")) { + if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check")) { break } v.reset(OpInvalid) @@ -10285,9 +10271,7 @@ func rewriteValuegeneric_OpNilCheck(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpNot(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpNot(v *Value) bool { // match: (Not (Eq64 x y)) // cond: // result: (Neq64 x y) @@ -10920,9 +10904,7 @@ func rewriteValuegeneric_OpNot(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpOffPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpOffPtr(v *Value) bool { // match: (OffPtr (OffPtr p [b]) [a]) // cond: // result: (OffPtr p [a+b]) @@ -10957,7 +10939,7 @@ func rewriteValuegeneric_OpOffPtr(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpOr16(v *Value) bool { b := v.Block _ = b // match: (Or16 (Const16 [c]) (Const16 [d])) @@ -11191,7 +11173,7 @@ func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpOr32(v *Value) bool { b := v.Block _ = b // match: (Or32 (Const32 [c]) (Const32 [d])) @@ -11425,7 +11407,7 @@ func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpOr64(v *Value) bool { b := v.Block _ = b // match: (Or64 (Const64 [c]) (Const64 [d])) @@ -11659,7 +11641,7 @@ func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpOr8(v *Value) bool { b := v.Block _ = b // match: (Or8 (Const8 [c]) (Const8 [d])) @@ -11893,9 +11875,7 @@ func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpPhi(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpPhi(v *Value) bool { // match: (Phi (Const8 [c]) (Const8 [c])) // cond: // result: (Const8 [c]) @@ -11990,12 +11970,16 @@ func rewriteValuegeneric_OpPhi(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { +func rewriteValuegeneric_OpPtrIndex(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (PtrIndex <t> ptr idx) // cond: config.PtrSize == 4 - // result: (AddPtr ptr (Mul32 <config.fe.TypeInt()> idx (Const32 <config.fe.TypeInt()> [t.ElemType().Size()]))) + // result: (AddPtr ptr (Mul32 <fe.TypeInt()> idx (Const32 <fe.TypeInt()> [t.ElemType().Size()]))) for { t := v.Type ptr := v.Args[0] @@ -12005,9 +11989,9 @@ func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { } v.reset(OpAddPtr) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMul32, config.fe.TypeInt()) + v0 := b.NewValue0(v.Pos, OpMul32, fe.TypeInt()) v0.AddArg(idx) - v1 := b.NewValue0(v.Pos, OpConst32, config.fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt()) v1.AuxInt = t.ElemType().Size() v0.AddArg(v1) v.AddArg(v0) @@ -12015,7 +11999,7 @@ func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { } // match: (PtrIndex <t> ptr idx) // cond: config.PtrSize == 8 - // result: (AddPtr ptr (Mul64 <config.fe.TypeInt()> idx (Const64 <config.fe.TypeInt()> [t.ElemType().Size()]))) + // result: (AddPtr ptr (Mul64 <fe.TypeInt()> idx (Const64 <fe.TypeInt()> [t.ElemType().Size()]))) for { t := v.Type ptr := v.Args[0] @@ -12025,9 +12009,9 @@ func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { } v.reset(OpAddPtr) v.AddArg(ptr) - v0 := b.NewValue0(v.Pos, OpMul64, config.fe.TypeInt()) + v0 := b.NewValue0(v.Pos, OpMul64, fe.TypeInt()) v0.AddArg(idx) - v1 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeInt()) + v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt()) v1.AuxInt = t.ElemType().Size() v0.AddArg(v1) v.AddArg(v0) @@ -12035,9 +12019,7 @@ func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRound32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpRound32F(v *Value) bool { // match: (Round32F x:(Const32F)) // cond: // result: x @@ -12053,9 +12035,7 @@ func rewriteValuegeneric_OpRound32F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRound64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpRound64F(v *Value) bool { // match: (Round64F x:(Const64F)) // cond: // result: x @@ -12071,7 +12051,7 @@ func rewriteValuegeneric_OpRound64F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh16Ux16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh16Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux16 <t> x (Const16 [c])) @@ -12109,7 +12089,7 @@ func rewriteValuegeneric_OpRsh16Ux16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh16Ux32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh16Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux32 <t> x (Const32 [c])) @@ -12147,9 +12127,13 @@ func rewriteValuegeneric_OpRsh16Ux32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16Ux64 (Const16 [c]) (Const64 [d])) // cond: // result: (Const16 [int64(int16(uint16(c) >> uint64(d)))]) @@ -12248,7 +12232,7 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { } // match: (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - // result: (Rsh16Ux64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + // result: (Rsh16Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) for { v_0 := v.Args[0] if v_0.Op != OpLsh16x64 { @@ -12279,14 +12263,14 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { } v.reset(OpRsh16Ux64) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = c1 - c2 + c3 v.AddArg(v0) return true } // match: (Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) // cond: - // result: (ZeroExt8to16 (Trunc16to8 <config.fe.TypeUInt8()> x)) + // result: (ZeroExt8to16 (Trunc16to8 <fe.TypeUInt8()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh16x64 { @@ -12308,14 +12292,14 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { break } v.reset(OpZeroExt8to16) - v0 := b.NewValue0(v.Pos, OpTrunc16to8, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpTrunc16to8, fe.TypeUInt8()) v0.AddArg(x) v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpRsh16Ux8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh16Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux8 <t> x (Const8 [c])) @@ -12353,7 +12337,7 @@ func rewriteValuegeneric_OpRsh16Ux8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh16x16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh16x16(v *Value) bool { b := v.Block _ = b // match: (Rsh16x16 <t> x (Const16 [c])) @@ -12391,7 +12375,7 @@ func rewriteValuegeneric_OpRsh16x16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh16x32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh16x32(v *Value) bool { b := v.Block _ = b // match: (Rsh16x32 <t> x (Const32 [c])) @@ -12429,9 +12413,13 @@ func rewriteValuegeneric_OpRsh16x32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh16x64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh16x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh16x64 (Const16 [c]) (Const64 [d])) // cond: // result: (Const16 [int64(int16(c) >> uint64(d))]) @@ -12514,7 +12502,7 @@ func rewriteValuegeneric_OpRsh16x64(v *Value, config *Config) bool { } // match: (Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) // cond: - // result: (SignExt8to16 (Trunc16to8 <config.fe.TypeInt8()> x)) + // result: (SignExt8to16 (Trunc16to8 <fe.TypeInt8()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh16x64 { @@ -12536,14 +12524,14 @@ func rewriteValuegeneric_OpRsh16x64(v *Value, config *Config) bool { break } v.reset(OpSignExt8to16) - v0 := b.NewValue0(v.Pos, OpTrunc16to8, config.fe.TypeInt8()) + v0 := b.NewValue0(v.Pos, OpTrunc16to8, fe.TypeInt8()) v0.AddArg(x) v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpRsh16x8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh16x8(v *Value) bool { b := v.Block _ = b // match: (Rsh16x8 <t> x (Const8 [c])) @@ -12581,7 +12569,7 @@ func rewriteValuegeneric_OpRsh16x8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh32Ux16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh32Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux16 <t> x (Const16 [c])) @@ -12619,7 +12607,7 @@ func rewriteValuegeneric_OpRsh32Ux16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh32Ux32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh32Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 <t> x (Const32 [c])) @@ -12657,9 +12645,13 @@ func rewriteValuegeneric_OpRsh32Ux32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32Ux64 (Const32 [c]) (Const64 [d])) // cond: // result: (Const32 [int64(int32(uint32(c) >> uint64(d)))]) @@ -12758,7 +12750,7 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { } // match: (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - // result: (Rsh32Ux64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + // result: (Rsh32Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) for { v_0 := v.Args[0] if v_0.Op != OpLsh32x64 { @@ -12789,14 +12781,14 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { } v.reset(OpRsh32Ux64) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = c1 - c2 + c3 v.AddArg(v0) return true } // match: (Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) // cond: - // result: (ZeroExt8to32 (Trunc32to8 <config.fe.TypeUInt8()> x)) + // result: (ZeroExt8to32 (Trunc32to8 <fe.TypeUInt8()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh32x64 { @@ -12818,14 +12810,14 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { break } v.reset(OpZeroExt8to32) - v0 := b.NewValue0(v.Pos, OpTrunc32to8, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpTrunc32to8, fe.TypeUInt8()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) // cond: - // result: (ZeroExt16to32 (Trunc32to16 <config.fe.TypeUInt16()> x)) + // result: (ZeroExt16to32 (Trunc32to16 <fe.TypeUInt16()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh32x64 { @@ -12847,14 +12839,14 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { break } v.reset(OpZeroExt16to32) - v0 := b.NewValue0(v.Pos, OpTrunc32to16, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpTrunc32to16, fe.TypeUInt16()) v0.AddArg(x) v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpRsh32Ux8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh32Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux8 <t> x (Const8 [c])) @@ -12892,7 +12884,7 @@ func rewriteValuegeneric_OpRsh32Ux8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh32x16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh32x16(v *Value) bool { b := v.Block _ = b // match: (Rsh32x16 <t> x (Const16 [c])) @@ -12930,7 +12922,7 @@ func rewriteValuegeneric_OpRsh32x16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh32x32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh32x32(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 <t> x (Const32 [c])) @@ -12968,9 +12960,13 @@ func rewriteValuegeneric_OpRsh32x32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh32x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh32x64 (Const32 [c]) (Const64 [d])) // cond: // result: (Const32 [int64(int32(c) >> uint64(d))]) @@ -13053,7 +13049,7 @@ func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool { } // match: (Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) // cond: - // result: (SignExt8to32 (Trunc32to8 <config.fe.TypeInt8()> x)) + // result: (SignExt8to32 (Trunc32to8 <fe.TypeInt8()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh32x64 { @@ -13075,14 +13071,14 @@ func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool { break } v.reset(OpSignExt8to32) - v0 := b.NewValue0(v.Pos, OpTrunc32to8, config.fe.TypeInt8()) + v0 := b.NewValue0(v.Pos, OpTrunc32to8, fe.TypeInt8()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) // cond: - // result: (SignExt16to32 (Trunc32to16 <config.fe.TypeInt16()> x)) + // result: (SignExt16to32 (Trunc32to16 <fe.TypeInt16()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh32x64 { @@ -13104,14 +13100,14 @@ func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool { break } v.reset(OpSignExt16to32) - v0 := b.NewValue0(v.Pos, OpTrunc32to16, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpTrunc32to16, fe.TypeInt16()) v0.AddArg(x) v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpRsh32x8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh32x8(v *Value) bool { b := v.Block _ = b // match: (Rsh32x8 <t> x (Const8 [c])) @@ -13149,7 +13145,7 @@ func rewriteValuegeneric_OpRsh32x8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh64Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux16 <t> x (Const16 [c])) @@ -13187,7 +13183,7 @@ func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh64Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux32 <t> x (Const32 [c])) @@ -13225,9 +13221,13 @@ func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64Ux64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [int64(uint64(c) >> uint64(d))]) @@ -13326,7 +13326,7 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { } // match: (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - // result: (Rsh64Ux64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + // result: (Rsh64Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) for { v_0 := v.Args[0] if v_0.Op != OpLsh64x64 { @@ -13357,14 +13357,14 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { } v.reset(OpRsh64Ux64) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = c1 - c2 + c3 v.AddArg(v0) return true } // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) // cond: - // result: (ZeroExt8to64 (Trunc64to8 <config.fe.TypeUInt8()> x)) + // result: (ZeroExt8to64 (Trunc64to8 <fe.TypeUInt8()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh64x64 { @@ -13386,14 +13386,14 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { break } v.reset(OpZeroExt8to64) - v0 := b.NewValue0(v.Pos, OpTrunc64to8, config.fe.TypeUInt8()) + v0 := b.NewValue0(v.Pos, OpTrunc64to8, fe.TypeUInt8()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) // cond: - // result: (ZeroExt16to64 (Trunc64to16 <config.fe.TypeUInt16()> x)) + // result: (ZeroExt16to64 (Trunc64to16 <fe.TypeUInt16()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh64x64 { @@ -13415,14 +13415,14 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { break } v.reset(OpZeroExt16to64) - v0 := b.NewValue0(v.Pos, OpTrunc64to16, config.fe.TypeUInt16()) + v0 := b.NewValue0(v.Pos, OpTrunc64to16, fe.TypeUInt16()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) // cond: - // result: (ZeroExt32to64 (Trunc64to32 <config.fe.TypeUInt32()> x)) + // result: (ZeroExt32to64 (Trunc64to32 <fe.TypeUInt32()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh64x64 { @@ -13444,14 +13444,14 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { break } v.reset(OpZeroExt32to64) - v0 := b.NewValue0(v.Pos, OpTrunc64to32, config.fe.TypeUInt32()) + v0 := b.NewValue0(v.Pos, OpTrunc64to32, fe.TypeUInt32()) v0.AddArg(x) v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh64Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux8 <t> x (Const8 [c])) @@ -13489,7 +13489,7 @@ func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh64x16(v *Value) bool { b := v.Block _ = b // match: (Rsh64x16 <t> x (Const16 [c])) @@ -13527,7 +13527,7 @@ func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh64x32(v *Value) bool { b := v.Block _ = b // match: (Rsh64x32 <t> x (Const32 [c])) @@ -13565,9 +13565,13 @@ func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh64x64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh64x64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c >> uint64(d)]) @@ -13650,7 +13654,7 @@ func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { } // match: (Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) // cond: - // result: (SignExt8to64 (Trunc64to8 <config.fe.TypeInt8()> x)) + // result: (SignExt8to64 (Trunc64to8 <fe.TypeInt8()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh64x64 { @@ -13672,14 +13676,14 @@ func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { break } v.reset(OpSignExt8to64) - v0 := b.NewValue0(v.Pos, OpTrunc64to8, config.fe.TypeInt8()) + v0 := b.NewValue0(v.Pos, OpTrunc64to8, fe.TypeInt8()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) // cond: - // result: (SignExt16to64 (Trunc64to16 <config.fe.TypeInt16()> x)) + // result: (SignExt16to64 (Trunc64to16 <fe.TypeInt16()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh64x64 { @@ -13701,14 +13705,14 @@ func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { break } v.reset(OpSignExt16to64) - v0 := b.NewValue0(v.Pos, OpTrunc64to16, config.fe.TypeInt16()) + v0 := b.NewValue0(v.Pos, OpTrunc64to16, fe.TypeInt16()) v0.AddArg(x) v.AddArg(v0) return true } // match: (Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) // cond: - // result: (SignExt32to64 (Trunc64to32 <config.fe.TypeInt32()> x)) + // result: (SignExt32to64 (Trunc64to32 <fe.TypeInt32()> x)) for { v_0 := v.Args[0] if v_0.Op != OpLsh64x64 { @@ -13730,14 +13734,14 @@ func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { break } v.reset(OpSignExt32to64) - v0 := b.NewValue0(v.Pos, OpTrunc64to32, config.fe.TypeInt32()) + v0 := b.NewValue0(v.Pos, OpTrunc64to32, fe.TypeInt32()) v0.AddArg(x) v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh64x8(v *Value) bool { b := v.Block _ = b // match: (Rsh64x8 <t> x (Const8 [c])) @@ -13775,7 +13779,7 @@ func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh8Ux16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8Ux16(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux16 <t> x (Const16 [c])) @@ -13813,7 +13817,7 @@ func rewriteValuegeneric_OpRsh8Ux16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh8Ux32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8Ux32(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux32 <t> x (Const32 [c])) @@ -13851,9 +13855,13 @@ func rewriteValuegeneric_OpRsh8Ux32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Rsh8Ux64 (Const8 [c]) (Const64 [d])) // cond: // result: (Const8 [int64(int8(uint8(c) >> uint64(d)))]) @@ -13952,7 +13960,7 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { } // match: (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) - // result: (Rsh8Ux64 x (Const64 <config.fe.TypeUInt64()> [c1-c2+c3])) + // result: (Rsh8Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) for { v_0 := v.Args[0] if v_0.Op != OpLsh8x64 { @@ -13983,14 +13991,14 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { } v.reset(OpRsh8Ux64) v.AddArg(x) - v0 := b.NewValue0(v.Pos, OpConst64, config.fe.TypeUInt64()) + v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64()) v0.AuxInt = c1 - c2 + c3 v.AddArg(v0) return true } return false } -func rewriteValuegeneric_OpRsh8Ux8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8Ux8(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux8 <t> x (Const8 [c])) @@ -14028,7 +14036,7 @@ func rewriteValuegeneric_OpRsh8Ux8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh8x16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8x16(v *Value) bool { b := v.Block _ = b // match: (Rsh8x16 <t> x (Const16 [c])) @@ -14066,7 +14074,7 @@ func rewriteValuegeneric_OpRsh8x16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh8x32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8x32(v *Value) bool { b := v.Block _ = b // match: (Rsh8x32 <t> x (Const32 [c])) @@ -14104,7 +14112,7 @@ func rewriteValuegeneric_OpRsh8x32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh8x64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8x64(v *Value) bool { b := v.Block _ = b // match: (Rsh8x64 (Const8 [c]) (Const64 [d])) @@ -14189,7 +14197,7 @@ func rewriteValuegeneric_OpRsh8x64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpRsh8x8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8x8(v *Value) bool { b := v.Block _ = b // match: (Rsh8x8 <t> x (Const8 [c])) @@ -14227,9 +14235,7 @@ func rewriteValuegeneric_OpRsh8x8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSignExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSignExt16to32(v *Value) bool { // match: (SignExt16to32 (Const16 [c])) // cond: // result: (Const32 [int64( int16(c))]) @@ -14270,9 +14276,7 @@ func rewriteValuegeneric_OpSignExt16to32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSignExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSignExt16to64(v *Value) bool { // match: (SignExt16to64 (Const16 [c])) // cond: // result: (Const64 [int64( int16(c))]) @@ -14313,9 +14317,7 @@ func rewriteValuegeneric_OpSignExt16to64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSignExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSignExt32to64(v *Value) bool { // match: (SignExt32to64 (Const32 [c])) // cond: // result: (Const64 [int64( int32(c))]) @@ -14356,9 +14358,7 @@ func rewriteValuegeneric_OpSignExt32to64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSignExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSignExt8to16(v *Value) bool { // match: (SignExt8to16 (Const8 [c])) // cond: // result: (Const16 [int64( int8(c))]) @@ -14399,9 +14399,7 @@ func rewriteValuegeneric_OpSignExt8to16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSignExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSignExt8to32(v *Value) bool { // match: (SignExt8to32 (Const8 [c])) // cond: // result: (Const32 [int64( int8(c))]) @@ -14442,9 +14440,7 @@ func rewriteValuegeneric_OpSignExt8to32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSignExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSignExt8to64(v *Value) bool { // match: (SignExt8to64 (Const8 [c])) // cond: // result: (Const64 [int64( int8(c))]) @@ -14485,9 +14481,7 @@ func rewriteValuegeneric_OpSignExt8to64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSliceCap(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSliceCap(v *Value) bool { // match: (SliceCap (SliceMake _ _ (Const64 <t> [c]))) // cond: // result: (Const64 <t> [c]) @@ -14562,9 +14556,7 @@ func rewriteValuegeneric_OpSliceCap(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSliceLen(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSliceLen(v *Value) bool { // match: (SliceLen (SliceMake _ (Const64 <t> [c]) _)) // cond: // result: (Const64 <t> [c]) @@ -14622,9 +14614,7 @@ func rewriteValuegeneric_OpSliceLen(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSlicePtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSlicePtr(v *Value) bool { // match: (SlicePtr (SliceMake (SlicePtr x) _ _)) // cond: // result: (SlicePtr x) @@ -14644,9 +14634,7 @@ func rewriteValuegeneric_OpSlicePtr(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSlicemask(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSlicemask(v *Value) bool { // match: (Slicemask (Const32 [x])) // cond: x > 0 // result: (Const32 [-1]) @@ -14711,9 +14699,7 @@ func rewriteValuegeneric_OpSlicemask(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSqrt(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSqrt(v *Value) bool { // match: (Sqrt (Const64F [c])) // cond: // result: (Const64F [f2i(math.Sqrt(i2f(c)))]) @@ -14729,9 +14715,13 @@ func rewriteValuegeneric_OpSqrt(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { +func rewriteValuegeneric_OpStore(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (Store _ (StructMake0) mem) // cond: // result: mem @@ -14889,7 +14879,7 @@ func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { return true } // match: (Store {t} dst (Load src mem) mem) - // cond: !config.fe.CanSSA(t.(Type)) + // cond: !fe.CanSSA(t.(Type)) // result: (Move {t} [t.(Type).Size()] dst src mem) for { t := v.Aux @@ -14903,7 +14893,7 @@ func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { if mem != v.Args[2] { break } - if !(!config.fe.CanSSA(t.(Type))) { + if !(!fe.CanSSA(t.(Type))) { break } v.reset(OpMove) @@ -14915,7 +14905,7 @@ func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { return true } // match: (Store {t} dst (Load src mem) (VarDef {x} mem)) - // cond: !config.fe.CanSSA(t.(Type)) + // cond: !fe.CanSSA(t.(Type)) // result: (Move {t} [t.(Type).Size()] dst src (VarDef {x} mem)) for { t := v.Aux @@ -14934,7 +14924,7 @@ func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { if mem != v_2.Args[0] { break } - if !(!config.fe.CanSSA(t.(Type))) { + if !(!fe.CanSSA(t.(Type))) { break } v.reset(OpMove) @@ -15046,9 +15036,7 @@ func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpStringLen(v *Value) bool { // match: (StringLen (StringMake _ (Const64 <t> [c]))) // cond: // result: (Const64 <t> [c]) @@ -15070,9 +15058,7 @@ func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpStringPtr(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpStringPtr(v *Value) bool { // match: (StringPtr (StringMake (Const64 <t> [c]) _)) // cond: // result: (Const64 <t> [c]) @@ -15094,9 +15080,13 @@ func rewriteValuegeneric_OpStringPtr(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { +func rewriteValuegeneric_OpStructSelect(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config + fe := config.fe + _ = fe // match: (StructSelect (StructMake1 x)) // cond: // result: x @@ -15265,7 +15255,7 @@ func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { return true } // match: (StructSelect [i] x:(Load <t> ptr mem)) - // cond: !config.fe.CanSSA(t) + // cond: !fe.CanSSA(t) // result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem) for { i := v.AuxInt @@ -15276,7 +15266,7 @@ func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { t := x.Type ptr := x.Args[0] mem := x.Args[1] - if !(!config.fe.CanSSA(t)) { + if !(!fe.CanSSA(t)) { break } b = x.Block @@ -15308,7 +15298,7 @@ func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpSub16(v *Value) bool { b := v.Block _ = b // match: (Sub16 (Const16 [c]) (Const16 [d])) @@ -15512,7 +15502,7 @@ func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpSub32(v *Value) bool { b := v.Block _ = b // match: (Sub32 (Const32 [c]) (Const32 [d])) @@ -15716,9 +15706,7 @@ func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSub32F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSub32F(v *Value) bool { // match: (Sub32F (Const32F [c]) (Const32F [d])) // cond: // result: (Const32F [f2i(float64(i2f32(c) - i2f32(d)))]) @@ -15756,7 +15744,7 @@ func rewriteValuegeneric_OpSub32F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpSub64(v *Value) bool { b := v.Block _ = b // match: (Sub64 (Const64 [c]) (Const64 [d])) @@ -15960,9 +15948,7 @@ func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSub64F(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpSub64F(v *Value) bool { // match: (Sub64F (Const64F [c]) (Const64F [d])) // cond: // result: (Const64F [f2i(i2f(c) - i2f(d))]) @@ -16000,7 +15986,7 @@ func rewriteValuegeneric_OpSub64F(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpSub8(v *Value) bool { b := v.Block _ = b // match: (Sub8 (Const8 [c]) (Const8 [d])) @@ -16204,9 +16190,7 @@ func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpTrunc16to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpTrunc16to8(v *Value) bool { // match: (Trunc16to8 (Const16 [c])) // cond: // result: (Const8 [int64(int8(c))]) @@ -16271,9 +16255,7 @@ func rewriteValuegeneric_OpTrunc16to8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpTrunc32to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpTrunc32to16(v *Value) bool { // match: (Trunc32to16 (Const32 [c])) // cond: // result: (Const16 [int64(int16(c))]) @@ -16364,9 +16346,7 @@ func rewriteValuegeneric_OpTrunc32to16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpTrunc32to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpTrunc32to8(v *Value) bool { // match: (Trunc32to8 (Const32 [c])) // cond: // result: (Const8 [int64(int8(c))]) @@ -16431,9 +16411,7 @@ func rewriteValuegeneric_OpTrunc32to8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpTrunc64to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpTrunc64to16(v *Value) bool { // match: (Trunc64to16 (Const64 [c])) // cond: // result: (Const16 [int64(int16(c))]) @@ -16524,9 +16502,7 @@ func rewriteValuegeneric_OpTrunc64to16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpTrunc64to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpTrunc64to32(v *Value) bool { // match: (Trunc64to32 (Const64 [c])) // cond: // result: (Const32 [int64(int32(c))]) @@ -16643,9 +16619,7 @@ func rewriteValuegeneric_OpTrunc64to32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpTrunc64to8(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpTrunc64to8(v *Value) bool { // match: (Trunc64to8 (Const64 [c])) // cond: // result: (Const8 [int64(int8(c))]) @@ -16710,7 +16684,7 @@ func rewriteValuegeneric_OpTrunc64to8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpXor16(v *Value) bool { b := v.Block _ = b // match: (Xor16 (Const16 [c]) (Const16 [d])) @@ -16928,7 +16902,7 @@ func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpXor32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpXor32(v *Value) bool { b := v.Block _ = b // match: (Xor32 (Const32 [c]) (Const32 [d])) @@ -17146,7 +17120,7 @@ func rewriteValuegeneric_OpXor32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpXor64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpXor64(v *Value) bool { b := v.Block _ = b // match: (Xor64 (Const64 [c]) (Const64 [d])) @@ -17364,7 +17338,7 @@ func rewriteValuegeneric_OpXor64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpXor8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpXor8(v *Value) bool { b := v.Block _ = b // match: (Xor8 (Const8 [c]) (Const8 [d])) @@ -17582,9 +17556,11 @@ func rewriteValuegeneric_OpXor8(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpZero(v *Value, config *Config) bool { +func rewriteValuegeneric_OpZero(v *Value) bool { b := v.Block _ = b + config := b.Func.Config + _ = config // match: (Zero (Load (OffPtr [c] (SP)) mem) mem) // cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize // result: mem @@ -17616,9 +17592,7 @@ func rewriteValuegeneric_OpZero(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpZeroExt16to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool { // match: (ZeroExt16to32 (Const16 [c])) // cond: // result: (Const32 [int64(uint16(c))]) @@ -17659,9 +17633,7 @@ func rewriteValuegeneric_OpZeroExt16to32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpZeroExt16to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool { // match: (ZeroExt16to64 (Const16 [c])) // cond: // result: (Const64 [int64(uint16(c))]) @@ -17702,9 +17674,7 @@ func rewriteValuegeneric_OpZeroExt16to64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpZeroExt32to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool { // match: (ZeroExt32to64 (Const32 [c])) // cond: // result: (Const64 [int64(uint32(c))]) @@ -17745,9 +17715,7 @@ func rewriteValuegeneric_OpZeroExt32to64(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpZeroExt8to16(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool { // match: (ZeroExt8to16 (Const8 [c])) // cond: // result: (Const16 [int64( uint8(c))]) @@ -17788,9 +17756,7 @@ func rewriteValuegeneric_OpZeroExt8to16(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpZeroExt8to32(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool { // match: (ZeroExt8to32 (Const8 [c])) // cond: // result: (Const32 [int64( uint8(c))]) @@ -17831,9 +17797,7 @@ func rewriteValuegeneric_OpZeroExt8to32(v *Value, config *Config) bool { } return false } -func rewriteValuegeneric_OpZeroExt8to64(v *Value, config *Config) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpZeroExt8to64(v *Value) bool { // match: (ZeroExt8to64 (Const8 [c])) // cond: // result: (Const64 [int64( uint8(c))]) @@ -17874,7 +17838,11 @@ func rewriteValuegeneric_OpZeroExt8to64(v *Value, config *Config) bool { } return false } -func rewriteBlockgeneric(b *Block, config *Config) bool { +func rewriteBlockgeneric(b *Block) bool { + config := b.Func.Config + _ = config + fe := config.fe + _ = fe switch b.Kind { case BlockIf: // match: (If (Not cond) yes no) |