cmd/compile: rewrite some AMD64 rules to use typed aux fields

Surprisingly many rules needed no modification.

Use wrapper functions for aux like we did for auxint.
Simplifies things a bit.

Change-Id: I2e852e77f1585dcb306a976ab9335f1ac5b4a770
Reviewed-on: https://go-review.googlesource.com/c/go/+/227961
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Michael Munday <mike.munday@ibm.com>

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index f9ab02a7abcad832d67de9861fe24bd1f67aebbb..367e88f2e5504e2bff32d1784c5c942eda416152 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -3,113 +3,114 @@
 // license that can be found in the LICENSE file.
 
 // Lowering arithmetic
-(Add(64|32|16|8) ...) -> (ADD(Q|L|L|L) ...)
-(AddPtr ...) -> (ADDQ ...)
-(Add(32|64)F ...) -> (ADDS(S|D) ...)
+(Add(64|32|16|8) ...) => (ADD(Q|L|L|L) ...)
+(AddPtr ...) => (ADDQ ...)
+(Add(32|64)F ...) => (ADDS(S|D) ...)
 
-(Sub(64|32|16|8) ...) -> (SUB(Q|L|L|L) ...)
-(SubPtr ...) -> (SUBQ ...)
-(Sub(32|64)F ...) -> (SUBS(S|D) ...)
+(Sub(64|32|16|8) ...) => (SUB(Q|L|L|L) ...)
+(SubPtr ...) => (SUBQ ...)
+(Sub(32|64)F ...) => (SUBS(S|D) ...)
 
-(Mul(64|32|16|8) ...) -> (MUL(Q|L|L|L) ...)
-(Mul(32|64)F ...) -> (MULS(S|D) ...)
+(Mul(64|32|16|8) ...) => (MUL(Q|L|L|L) ...)
+(Mul(32|64)F ...) => (MULS(S|D) ...)
 
-(Select0 (Mul64uover x y)) -> (Select0 <typ.UInt64> (MULQU x y))
-(Select0 (Mul32uover x y)) -> (Select0 <typ.UInt32> (MULLU x y))
-(Select1 (Mul(64|32)uover x y)) -> (SETO (Select1 <types.TypeFlags> (MUL(Q|L)U x y)))
+(Select0 (Mul64uover x y)) => (Select0 <typ.UInt64> (MULQU x y))
+(Select0 (Mul32uover x y)) => (Select0 <typ.UInt32> (MULLU x y))
+(Select1 (Mul(64|32)uover x y)) => (SETO (Select1 <types.TypeFlags> (MUL(Q|L)U x y)))
 
-(Hmul(64|32) ...) -> (HMUL(Q|L) ...)
-(Hmul(64|32)u ...) -> (HMUL(Q|L)U ...)
+(Hmul(64|32) ...) => (HMUL(Q|L) ...)
+(Hmul(64|32)u ...) => (HMUL(Q|L)U ...)
 
-(Div(64|32|16) [a] x y) -> (Select0 (DIV(Q|L|W) [a] x y))
-(Div8  x y) -> (Select0 (DIVW  (SignExt8to16 x) (SignExt8to16 y)))
-(Div(64|32|16)u x y) -> (Select0 (DIV(Q|L|W)U x y))
-(Div8u x y) -> (Select0 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)))
-(Div(32|64)F ...) -> (DIVS(S|D) ...)
+(Div(64|32|16) [a] x y) => (Select0 (DIV(Q|L|W) [a] x y))
+(Div8  x y) => (Select0 (DIVW  (SignExt8to16 x) (SignExt8to16 y)))
+(Div(64|32|16)u x y) => (Select0 (DIV(Q|L|W)U x y))
+(Div8u x y) => (Select0 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)))
+(Div(32|64)F ...) => (DIVS(S|D) ...)
 
-(Select0 (Add64carry x y c)) ->
+(Select0 (Add64carry x y c)) =>
        (Select0 <typ.UInt64> (ADCQ x y (Select1 <types.TypeFlags> (NEGLflags c))))
-(Select1 (Add64carry x y c)) ->
+(Select1 (Add64carry x y c)) =>
        (NEGQ <typ.UInt64> (SBBQcarrymask <typ.UInt64> (Select1 <types.TypeFlags> (ADCQ x y (Select1 <types.TypeFlags> (NEGLflags c))))))
-(Select0 (Sub64borrow x y c)) ->
+(Select0 (Sub64borrow x y c)) =>
        (Select0 <typ.UInt64> (SBBQ x y (Select1 <types.TypeFlags> (NEGLflags c))))
-(Select1 (Sub64borrow x y c)) ->
+(Select1 (Sub64borrow x y c)) =>
        (NEGQ <typ.UInt64> (SBBQcarrymask <typ.UInt64> (Select1 <types.TypeFlags> (SBBQ x y (Select1 <types.TypeFlags> (NEGLflags c))))))
 
 // Optimize ADCQ and friends
-(ADCQ x (MOVQconst [c]) carry) && is32Bit(c) -> (ADCQconst x [c] carry)
-(ADCQ x y (FlagEQ)) -> (ADDQcarry x y)
-(ADCQconst x [c] (FlagEQ)) -> (ADDQconstcarry x [c])
-(ADDQcarry x (MOVQconst [c])) && is32Bit(c) -> (ADDQconstcarry x [c])
-(SBBQ x (MOVQconst [c]) borrow) && is32Bit(c) -> (SBBQconst x [c] borrow)
-(SBBQ x y (FlagEQ)) -> (SUBQborrow x y)
-(SBBQconst x [c] (FlagEQ)) -> (SUBQconstborrow x [c])
-(SUBQborrow x (MOVQconst [c])) && is32Bit(c) -> (SUBQconstborrow x [c])
-(Select1 (NEGLflags (MOVQconst [0]))) -> (FlagEQ)
-(Select1 (NEGLflags (NEGQ (SBBQcarrymask x)))) -> x
+(ADCQ x (MOVQconst [c]) carry) && is32Bit(c) => (ADCQconst x [int32(c)] carry)
+(ADCQ x y (FlagEQ)) => (ADDQcarry x y)
+(ADCQconst x [c] (FlagEQ)) => (ADDQconstcarry x [c])
+(ADDQcarry x (MOVQconst [c])) && is32Bit(c) => (ADDQconstcarry x [int32(c)])
+(SBBQ x (MOVQconst [c]) borrow) && is32Bit(c) => (SBBQconst x [int32(c)] borrow)
+(SBBQ x y (FlagEQ)) => (SUBQborrow x y)
+(SBBQconst x [c] (FlagEQ)) => (SUBQconstborrow x [c])
+(SUBQborrow x (MOVQconst [c])) && is32Bit(c) => (SUBQconstborrow x [int32(c)])
+(Select1 (NEGLflags (MOVQconst [0]))) => (FlagEQ)
+(Select1 (NEGLflags (NEGQ (SBBQcarrymask x)))) => x
 
 
-(Mul64uhilo ...) -> (MULQU2 ...)
-(Div128u ...) -> (DIVQU2 ...)
+(Mul64uhilo ...) => (MULQU2 ...)
+(Div128u ...) => (DIVQU2 ...)
 
-(Avg64u ...) -> (AVGQU ...)
+(Avg64u ...) => (AVGQU ...)
 
-(Mod(64|32|16) [a] x y) -> (Select1 (DIV(Q|L|W) [a] x y))
-(Mod8  x y) -> (Select1 (DIVW  (SignExt8to16 x) (SignExt8to16 y)))
-(Mod(64|32|16)u x y) -> (Select1 (DIV(Q|L|W)U x y))
-(Mod8u x y) -> (Select1 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)))
+(Mod(64|32|16) [a] x y) => (Select1 (DIV(Q|L|W) [a] x y))
+(Mod8  x y) => (Select1 (DIVW  (SignExt8to16 x) (SignExt8to16 y)))
+(Mod(64|32|16)u x y) => (Select1 (DIV(Q|L|W)U x y))
+(Mod8u x y) => (Select1 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)))
 
-(And(64|32|16|8) ...) -> (AND(Q|L|L|L) ...)
-(Or(64|32|16|8) ...) -> (OR(Q|L|L|L) ...)
-(Xor(64|32|16|8) ...) -> (XOR(Q|L|L|L) ...)
-(Com(64|32|16|8) ...) -> (NOT(Q|L|L|L) ...)
+(And(64|32|16|8) ...) => (AND(Q|L|L|L) ...)
+(Or(64|32|16|8) ...) => (OR(Q|L|L|L) ...)
+(Xor(64|32|16|8) ...) => (XOR(Q|L|L|L) ...)
+(Com(64|32|16|8) ...) => (NOT(Q|L|L|L) ...)
 
-(Neg(64|32|16|8) ...) -> (NEG(Q|L|L|L) ...)
-(Neg32F x) -> (PXOR x (MOVSSconst <typ.Float32> [auxFrom32F(float32(math.Copysign(0, -1)))]))
-(Neg64F x) -> (PXOR x (MOVSDconst <typ.Float64> [auxFrom64F(math.Copysign(0, -1))]))
+(Neg(64|32|16|8) ...) => (NEG(Q|L|L|L) ...)
+(Neg32F x) => (PXOR x (MOVSSconst <typ.Float32> [float32(math.Copysign(0, -1))]))
+(Neg64F x) => (PXOR x (MOVSDconst <typ.Float64> [math.Copysign(0, -1)]))
 
 // Lowering boolean ops
-(AndB ...) -> (ANDL ...)
-(OrB ...) -> (ORL ...)
-(Not x) -> (XORLconst [1] x)
+(AndB ...) => (ANDL ...)
+(OrB ...) => (ORL ...)
+(Not x) => (XORLconst [1] x)
 
 // Lowering pointer arithmetic
-(OffPtr [off] ptr) && is32Bit(off) -> (ADDQconst [off] ptr)
-(OffPtr [off] ptr) -> (ADDQ (MOVQconst [off]) ptr)
+(OffPtr [off] ptr) && is32Bit(off) => (ADDQconst [int32(off)] ptr)
+(OffPtr [off] ptr) => (ADDQ (MOVQconst [off]) ptr)
 
 // Lowering other arithmetic
-(Ctz64 <t> x) -> (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <types.TypeFlags> (BSFQ x)))
-(Ctz32 x) -> (Select0 (BSFQ (BTSQconst <typ.UInt64> [32] x)))
-(Ctz16 x) -> (BSFL (BTSLconst <typ.UInt32> [16] x))
-(Ctz8  x) -> (BSFL (BTSLconst <typ.UInt32> [ 8] x))
+(Ctz64 <t> x) => (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <types.TypeFlags> (BSFQ x)))
+(Ctz32 x) => (Select0 (BSFQ (BTSQconst <typ.UInt64> [32] x)))
+(Ctz16 x) => (BSFL (BTSLconst <typ.UInt32> [16] x))
+(Ctz8  x) => (BSFL (BTSLconst <typ.UInt32> [ 8] x))
 
-(Ctz64NonZero x) -> (Select0 (BSFQ x))
-(Ctz32NonZero ...) -> (BSFL ...)
-(Ctz16NonZero ...) -> (BSFL ...)
-(Ctz8NonZero  ...) -> (BSFL ...)
+(Ctz64NonZero x) => (Select0 (BSFQ x))
+(Ctz32NonZero ...) => (BSFL ...)
+(Ctz16NonZero ...) => (BSFL ...)
+(Ctz8NonZero  ...) => (BSFL ...)
 
 // BitLen64 of a 64 bit value x requires checking whether x == 0, since BSRQ is undefined when x == 0.
 // However, for zero-extended values, we can cheat a bit, and calculate
 // BSR(x<<1 + 1), which is guaranteed to be non-zero, and which conveniently
 // places the index of the highest set bit where we want it.
-(BitLen64 <t> x) -> (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <types.TypeFlags> (BSRQ x))))
-(BitLen32 x) -> (Select0 (BSRQ (LEAQ1 <typ.UInt64> [1] (MOVLQZX <typ.UInt64> x) (MOVLQZX <typ.UInt64> x))))
-(BitLen16 x) -> (BSRL (LEAL1 <typ.UInt32> [1] (MOVWQZX <typ.UInt32> x) (MOVWQZX <typ.UInt32> x)))
-(BitLen8  x) -> (BSRL (LEAL1 <typ.UInt32> [1] (MOVBQZX <typ.UInt32> x) (MOVBQZX <typ.UInt32> x)))
+(BitLen64 <t> x) => (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <types.TypeFlags> (BSRQ x))))
+(BitLen32 x) => (Select0 (BSRQ (LEAQ1 <typ.UInt64> [1] (MOVLQZX <typ.UInt64> x) (MOVLQZX <typ.UInt64> x))))
+(BitLen16 x) => (BSRL (LEAL1 <typ.UInt32> [1] (MOVWQZX <typ.UInt32> x) (MOVWQZX <typ.UInt32> x)))
+(BitLen8  x) => (BSRL (LEAL1 <typ.UInt32> [1] (MOVBQZX <typ.UInt32> x) (MOVBQZX <typ.UInt32> x)))
 
-(Bswap(64|32) ...) -> (BSWAP(Q|L) ...)
+(Bswap(64|32) ...) => (BSWAP(Q|L) ...)
 
-(PopCount(64|32) ...) -> (POPCNT(Q|L) ...)
-(PopCount16 x) -> (POPCNTL (MOVWQZX <typ.UInt32> x))
-(PopCount8 x) -> (POPCNTL (MOVBQZX <typ.UInt32> x))
+(PopCount(64|32) ...) => (POPCNT(Q|L) ...)
+(PopCount16 x) => (POPCNTL (MOVWQZX <typ.UInt32> x))
+(PopCount8 x) => (POPCNTL (MOVBQZX <typ.UInt32> x))
 
-(Sqrt ...) -> (SQRTSD ...)
+(Sqrt ...) => (SQRTSD ...)
 
-(RoundToEven x) -> (ROUNDSD [0] x)
-(Floor x)      -> (ROUNDSD [1] x)
-(Ceil x)       -> (ROUNDSD [2] x)
-(Trunc x)      -> (ROUNDSD [3] x)
-(FMA x y z) -> (VFMADD231SD z x y)
+(RoundToEven x) => (ROUNDSD [0] x)
+(Floor x)       => (ROUNDSD [1] x)
+(Ceil x)        => (ROUNDSD [2] x)
+(Trunc x)       => (ROUNDSD [3] x)
+
+(FMA x y z) => (VFMADD231SD z x y)
 
 // Lowering extension
 // Note: we always extend to 64 bits even though some ops don't need that many result bits.

diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index 7b8dac3c4726ec2db14fb6c730f99a7d319556d7..c1a69e6e910212f9602406714c2853a763d6e6a5 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -671,10 +671,6 @@ func fprint(w io.Writer, n Node) {
                fmt.Fprintf(w, "%s := ", n.name)
                fprint(w, n.value)
                fmt.Fprintln(w)
-       case *Declare2:
-               fmt.Fprintf(w, "%s, %s := ", n.name1, n.name2)
-               fprint(w, n.value)
-               fmt.Fprintln(w)
        case *CondBreak:
                fmt.Fprintf(w, "if ")
                fprint(w, n.expr)
@@ -746,7 +742,7 @@ var predeclared = map[string]bool{
        "true":  true,
 }
 
-// declared reports if the body contains a Declare or Declare2 with the given name.
+// declared reports if the body contains a Declare with the given name.
 func (w *bodyBase) declared(name string) bool {
        if predeclared[name] {
                // Treat predeclared names as having already been declared.
@@ -758,9 +754,6 @@ func (w *bodyBase) declared(name string) bool {
                if decl, ok := s.(*Declare); ok && decl.name == name {
                        return true
                }
-               if decl, ok := s.(*Declare2); ok && (decl.name1 == name || decl.name2 == name) {
-                       return true
-               }
        }
        return false
 }
@@ -810,10 +803,6 @@ type (
                name  string
                value ast.Expr
        }
-       Declare2 struct {
-               name1, name2 string
-               value        ast.Expr
-       }
        // TODO: implement CondBreak as If + Break instead?
        CondBreak struct {
                expr              ast.Expr
@@ -855,12 +844,6 @@ func declf(name, format string, a ...interface{}) *Declare {
        return &Declare{name, exprf(format, a...)}
 }
 
-// decl2f constructs a simple "name1, name2 := value" declaration, using exprf for its
-// value.
-func decl2f(name1, name2, format string, a ...interface{}) *Declare2 {
-       return &Declare2{name1, name2, exprf(format, a...)}
-}
-
 // breakf constructs a simple "if cond { break }" statement, using exprf for its
 // condition.
 func breakf(format string, a ...interface{}) *CondBreak {
@@ -1051,11 +1034,7 @@ func genMatch0(rr *RuleRewrite, arch arch, match, v string, cnt map[string]int,
                if !token.IsIdentifier(e.name) || rr.declared(e.name) {
                        switch e.field {
                        case "Aux":
-                               rr.add(&If{
-                                       expr: exprf("%s.%s == nil", v, e.field),
-                                       stmt: breakf("%s == nil", e.name),
-                                       alt:  breakf("%s.%s.(%s) == %s", v, e.field, e.dclType, e.name),
-                               })
+                               rr.add(breakf("auxTo%s(%s.%s) != %s", strings.Title(e.dclType), v, e.field, e.name))
                        case "AuxInt":
                                rr.add(breakf("auxIntTo%s(%s.%s) != %s", strings.Title(e.dclType), v, e.field, e.name))
                        case "Type":
@@ -1064,12 +1043,7 @@ func genMatch0(rr *RuleRewrite, arch arch, match, v string, cnt map[string]int,
                } else {
                        switch e.field {
                        case "Aux":
-                               if e.dclType == "Sym" {
-                                       // TODO: kind of a hack - allows nil interface through
-                                       rr.add(decl2f(e.name, "_", "%s.Aux.(Sym)", v))
-                               } else {
-                                       rr.add(declf(e.name, "%s.%s.(%s)", v, e.field, e.dclType))
-                               }
+                               rr.add(declf(e.name, "auxTo%s(%s.%s)", strings.Title(e.dclType), v, e.field))
                        case "AuxInt":
                                rr.add(declf(e.name, "auxIntTo%s(%s.%s)", strings.Title(e.dclType), v, e.field))
                        case "Type":
@@ -1237,8 +1211,7 @@ func genResult0(rr *RuleRewrite, arch arch, result string, top, move bool, pos s
        if auxint != "" {
                if rr.typed {
                        // Make sure auxint value has the right type.
-                       rr.add(stmtf("var _auxint %s = %s", op.auxIntType(), auxint))
-                       rr.add(stmtf("%s.AuxInt = %sToAuxInt(_auxint)", v, op.auxIntType()))
+                       rr.add(stmtf("%s.AuxInt = %sToAuxInt(%s)", v, unTitle(op.auxIntType()), auxint))
                } else {
                        rr.add(stmtf("%s.AuxInt = %s", v, auxint))
                }
@@ -1246,8 +1219,7 @@ func genResult0(rr *RuleRewrite, arch arch, result string, top, move bool, pos s
        if aux != "" {
                if rr.typed {
                        // Make sure aux value has the right type.
-                       rr.add(stmtf("var _aux %s = %s", op.auxType(), aux))
-                       rr.add(stmtf("%s.Aux = _aux", v))
+                       rr.add(stmtf("%s.Aux = %sToAux(%s)", v, unTitle(op.auxType()), aux))
                } else {
                        rr.add(stmtf("%s.Aux = %s", v, aux))
                }
@@ -1807,3 +1779,7 @@ func (op opData) auxIntType() string {
                return "invalid"
        }
 }
+
+func unTitle(s string) string {
+       return strings.ToLower(s[:1]) + s[1:]
+}

diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index aed704599579a7b42fca6cef4e7eea70d70f3d84..a7f824b9140b7c15b80ee4fca71f91c54600fab2 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -593,10 +593,26 @@ func float32ToAuxInt(f float32) int64 {
 func float64ToAuxInt(f float64) int64 {
        return int64(math.Float64bits(f))
 }
-func ValAndOffToAuxInt(v ValAndOff) int64 {
+func valAndOffToAuxInt(v ValAndOff) int64 {
        return int64(v)
 }
 
+func auxToString(i interface{}) string {
+       return i.(string)
+}
+func auxToSym(i interface{}) Sym {
+       // TODO: kind of a hack - allows nil interface through
+       s, _ := i.(Sym)
+       return s
+}
+
+func stringToAux(s string) interface{} {
+       return s
+}
+func symToAux(s Sym) interface{} {
+       return s
+}
+
 // uaddOvf reports whether unsigned a+b would overflow.
 func uaddOvf(a, b int64) bool {
        return uint64(a)+uint64(b) < uint64(a)

diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index a392b20e54f5d3176ec16d9992d65f963e25831d..51b82b15f4fc22f0598c5877703b41e679b1a62c 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -1187,20 +1187,20 @@ func rewriteValueAMD64_OpAMD64ADCQ(v *Value) bool {
        v_0 := v.Args[0]
        // match: (ADCQ x (MOVQconst [c]) carry)
        // cond: is32Bit(c)
-       // result: (ADCQconst x [c] carry)
+       // result: (ADCQconst x [int32(c)] carry)
        for {
                for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
                        x := v_0
                        if v_1.Op != OpAMD64MOVQconst {
                                continue
                        }
-                       c := v_1.AuxInt
+                       c := auxIntToInt64(v_1.AuxInt)
                        carry := v_2
                        if !(is32Bit(c)) {
                                continue
                        }
                        v.reset(OpAMD64ADCQconst)
-                       v.AuxInt = c
+                       v.AuxInt = int32ToAuxInt(int32(c))
                        v.AddArg2(x, carry)
                        return true
                }
@@ -1226,13 +1226,13 @@ func rewriteValueAMD64_OpAMD64ADCQconst(v *Value) bool {
        // match: (ADCQconst x [c] (FlagEQ))
        // result: (ADDQconstcarry x [c])
        for {
-               c := v.AuxInt
+               c := auxIntToInt32(v.AuxInt)
                x := v_0
                if v_1.Op != OpAMD64FlagEQ {
                        break
                }
                v.reset(OpAMD64ADDQconstcarry)
-               v.AuxInt = c
+               v.AuxInt = int32ToAuxInt(c)
                v.AddArg(x)
                return true
        }
@@ -2097,19 +2097,19 @@ func rewriteValueAMD64_OpAMD64ADDQcarry(v *Value) bool {
        v_0 := v.Args[0]
        // match: (ADDQcarry x (MOVQconst [c]))
        // cond: is32Bit(c)
-       // result: (ADDQconstcarry x [c])
+       // result: (ADDQconstcarry x [int32(c)])
        for {
                for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
                        x := v_0
                        if v_1.Op != OpAMD64MOVQconst {
                                continue
                        }
-                       c := v_1.AuxInt
+                       c := auxIntToInt64(v_1.AuxInt)
                        if !(is32Bit(c)) {
                                continue
                        }
                        v.reset(OpAMD64ADDQconstcarry)
-                       v.AuxInt = c
+                       v.AuxInt = int32ToAuxInt(int32(c))
                        v.AddArg(x)
                        return true
                }
@@ -6946,7 +6946,7 @@ func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool {
                        break
                }
                off := auxIntToInt32(l.AuxInt)
-               sym, _ := l.Aux.(Sym)
+               sym := auxToSym(l.Aux)
                mem := l.Args[1]
                ptr := l.Args[0]
                if !(l.Uses == 1 && clobber(l)) {
@@ -6955,10 +6955,8 @@ func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool {
                b = l.Block
                v0 := b.NewValue0(l.Pos, OpAMD64CMPBconstload, types.TypeFlags)
                v.copyOf(v0)
-               var _auxint ValAndOff = makeValAndOff32(int32(c), off)
-               v0.AuxInt = ValAndOffToAuxInt(_auxint)
-               var _aux Sym = sym
-               v0.Aux = _aux
+               v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+               v0.Aux = symToAux(sym)
                v0.AddArg2(ptr, mem)
                return true
        }
@@ -7333,7 +7331,7 @@ func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool {
                        break
                }
                off := auxIntToInt32(l.AuxInt)
-               sym, _ := l.Aux.(Sym)
+               sym := auxToSym(l.Aux)
                mem := l.Args[1]
                ptr := l.Args[0]
                if !(l.Uses == 1 && clobber(l)) {
@@ -7342,10 +7340,8 @@ func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool {
                b = l.Block
                v0 := b.NewValue0(l.Pos, OpAMD64CMPLconstload, types.TypeFlags)
                v.copyOf(v0)
-               var _auxint ValAndOff = makeValAndOff32(c, off)
-               v0.AuxInt = ValAndOffToAuxInt(_auxint)
-               var _aux Sym = sym
-               v0.Aux = _aux
+               v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+               v0.Aux = symToAux(sym)
                v0.AddArg2(ptr, mem)
                return true
        }
@@ -7900,7 +7896,7 @@ func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool {
                        break
                }
                off := auxIntToInt32(l.AuxInt)
-               sym, _ := l.Aux.(Sym)
+               sym := auxToSym(l.Aux)
                mem := l.Args[1]
                ptr := l.Args[0]
                if !(l.Uses == 1 && clobber(l)) {
@@ -7909,10 +7905,8 @@ func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool {
                b = l.Block
                v0 := b.NewValue0(l.Pos, OpAMD64CMPQconstload, types.TypeFlags)
                v.copyOf(v0)
-               var _auxint ValAndOff = makeValAndOff32(c, off)
-               v0.AuxInt = ValAndOffToAuxInt(_auxint)
-               var _aux Sym = sym
-               v0.Aux = _aux
+               v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(c, off))
+               v0.Aux = symToAux(sym)
                v0.AddArg2(ptr, mem)
                return true
        }
@@ -8272,7 +8266,7 @@ func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool {
                        break
                }
                off := auxIntToInt32(l.AuxInt)
-               sym, _ := l.Aux.(Sym)
+               sym := auxToSym(l.Aux)
                mem := l.Args[1]
                ptr := l.Args[0]
                if !(l.Uses == 1 && clobber(l)) {
@@ -8281,10 +8275,8 @@ func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool {
                b = l.Block
                v0 := b.NewValue0(l.Pos, OpAMD64CMPWconstload, types.TypeFlags)
                v.copyOf(v0)
-               var _auxint ValAndOff = makeValAndOff32(int32(c), off)
-               v0.AuxInt = ValAndOffToAuxInt(_auxint)
-               var _aux Sym = sym
-               v0.Aux = _aux
+               v0.AuxInt = valAndOffToAuxInt(makeValAndOff32(int32(c), off))
+               v0.Aux = symToAux(sym)
                v0.AddArg2(ptr, mem)
                return true
        }
@@ -21179,19 +21171,19 @@ func rewriteValueAMD64_OpAMD64SBBQ(v *Value) bool {
        v_0 := v.Args[0]
        // match: (SBBQ x (MOVQconst [c]) borrow)
        // cond: is32Bit(c)
-       // result: (SBBQconst x [c] borrow)
+       // result: (SBBQconst x [int32(c)] borrow)
        for {
                x := v_0
                if v_1.Op != OpAMD64MOVQconst {
                        break
                }
-               c := v_1.AuxInt
+               c := auxIntToInt64(v_1.AuxInt)
                borrow := v_2
                if !(is32Bit(c)) {
                        break
                }
                v.reset(OpAMD64SBBQconst)
-               v.AuxInt = c
+               v.AuxInt = int32ToAuxInt(int32(c))
                v.AddArg2(x, borrow)
                return true
        }
@@ -21269,13 +21261,13 @@ func rewriteValueAMD64_OpAMD64SBBQconst(v *Value) bool {
        // match: (SBBQconst x [c] (FlagEQ))
        // result: (SUBQconstborrow x [c])
        for {
-               c := v.AuxInt
+               c := auxIntToInt32(v.AuxInt)
                x := v_0
                if v_1.Op != OpAMD64FlagEQ {
                        break
                }
                v.reset(OpAMD64SUBQconstborrow)
-               v.AuxInt = c
+               v.AuxInt = int32ToAuxInt(c)
                v.AddArg(x)
                return true
        }
@@ -26563,18 +26555,18 @@ func rewriteValueAMD64_OpAMD64SUBQborrow(v *Value) bool {
        v_0 := v.Args[0]
        // match: (SUBQborrow x (MOVQconst [c]))
        // cond: is32Bit(c)
-       // result: (SUBQconstborrow x [c])
+       // result: (SUBQconstborrow x [int32(c)])
        for {
                x := v_0
                if v_1.Op != OpAMD64MOVQconst {
                        break
                }
-               c := v_1.AuxInt
+               c := auxIntToInt64(v_1.AuxInt)
                if !(is32Bit(c)) {
                        break
                }
                v.reset(OpAMD64SUBQconstborrow)
-               v.AuxInt = c
+               v.AuxInt = int32ToAuxInt(int32(c))
                v.AddArg(x)
                return true
        }
@@ -28502,7 +28494,7 @@ func rewriteValueAMD64_OpBitLen16(v *Value) bool {
                x := v_0
                v.reset(OpAMD64BSRL)
                v0 := b.NewValue0(v.Pos, OpAMD64LEAL1, typ.UInt32)
-               v0.AuxInt = 1
+               v0.AuxInt = int32ToAuxInt(1)
                v1 := b.NewValue0(v.Pos, OpAMD64MOVWQZX, typ.UInt32)
                v1.AddArg(x)
                v2 := b.NewValue0(v.Pos, OpAMD64MOVWQZX, typ.UInt32)
@@ -28523,7 +28515,7 @@ func rewriteValueAMD64_OpBitLen32(v *Value) bool {
                v.reset(OpSelect0)
                v0 := b.NewValue0(v.Pos, OpAMD64BSRQ, types.NewTuple(typ.UInt64, types.TypeFlags))
                v1 := b.NewValue0(v.Pos, OpAMD64LEAQ1, typ.UInt64)
-               v1.AuxInt = 1
+               v1.AuxInt = int32ToAuxInt(1)
                v2 := b.NewValue0(v.Pos, OpAMD64MOVLQZX, typ.UInt64)
                v2.AddArg(x)
                v3 := b.NewValue0(v.Pos, OpAMD64MOVLQZX, typ.UInt64)
@@ -28544,14 +28536,14 @@ func rewriteValueAMD64_OpBitLen64(v *Value) bool {
                t := v.Type
                x := v_0
                v.reset(OpAMD64ADDQconst)
-               v.AuxInt = 1
+               v.AuxInt = int32ToAuxInt(1)
                v0 := b.NewValue0(v.Pos, OpAMD64CMOVQEQ, t)
                v1 := b.NewValue0(v.Pos, OpSelect0, t)
                v2 := b.NewValue0(v.Pos, OpAMD64BSRQ, types.NewTuple(typ.UInt64, types.TypeFlags))
                v2.AddArg(x)
                v1.AddArg(v2)
                v3 := b.NewValue0(v.Pos, OpAMD64MOVQconst, t)
-               v3.AuxInt = -1
+               v3.AuxInt = int64ToAuxInt(-1)
                v4 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
                v5 := b.NewValue0(v.Pos, OpAMD64BSRQ, types.NewTuple(typ.UInt64, types.TypeFlags))
                v5.AddArg(x)
@@ -28571,7 +28563,7 @@ func rewriteValueAMD64_OpBitLen8(v *Value) bool {
                x := v_0
                v.reset(OpAMD64BSRL)
                v0 := b.NewValue0(v.Pos, OpAMD64LEAL1, typ.UInt32)
-               v0.AuxInt = 1
+               v0.AuxInt = int32ToAuxInt(1)
                v1 := b.NewValue0(v.Pos, OpAMD64MOVBQZX, typ.UInt32)
                v1.AddArg(x)
                v2 := b.NewValue0(v.Pos, OpAMD64MOVBQZX, typ.UInt32)
@@ -28588,7 +28580,7 @@ func rewriteValueAMD64_OpCeil(v *Value) bool {
        for {
                x := v_0
                v.reset(OpAMD64ROUNDSD)
-               v.AuxInt = 2
+               v.AuxInt = int8ToAuxInt(2)
                v.AddArg(x)
                return true
        }
@@ -29475,7 +29467,7 @@ func rewriteValueAMD64_OpCtz16(v *Value) bool {
                x := v_0
                v.reset(OpAMD64BSFL)
                v0 := b.NewValue0(v.Pos, OpAMD64BTSLconst, typ.UInt32)
-               v0.AuxInt = 16
+               v0.AuxInt = int8ToAuxInt(16)
                v0.AddArg(x)
                v.AddArg(v0)
                return true
@@ -29492,7 +29484,7 @@ func rewriteValueAMD64_OpCtz32(v *Value) bool {
                v.reset(OpSelect0)
                v0 := b.NewValue0(v.Pos, OpAMD64BSFQ, types.NewTuple(typ.UInt64, types.TypeFlags))
                v1 := b.NewValue0(v.Pos, OpAMD64BTSQconst, typ.UInt64)
-               v1.AuxInt = 32
+               v1.AuxInt = int8ToAuxInt(32)
                v1.AddArg(x)
                v0.AddArg(v1)
                v.AddArg(v0)
@@ -29514,7 +29506,7 @@ func rewriteValueAMD64_OpCtz64(v *Value) bool {
                v1.AddArg(x)
                v0.AddArg(v1)
                v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, t)
-               v2.AuxInt = 64
+               v2.AuxInt = int64ToAuxInt(64)
                v3 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
                v4 := b.NewValue0(v.Pos, OpAMD64BSFQ, types.NewTuple(typ.UInt64, types.TypeFlags))
                v4.AddArg(x)
@@ -29548,7 +29540,7 @@ func rewriteValueAMD64_OpCtz8(v *Value) bool {
                x := v_0
                v.reset(OpAMD64BSFL)
                v0 := b.NewValue0(v.Pos, OpAMD64BTSLconst, typ.UInt32)
-               v0.AuxInt = 8
+               v0.AuxInt = int8ToAuxInt(8)
                v0.AddArg(x)
                v.AddArg(v0)
                return true
@@ -29562,12 +29554,12 @@ func rewriteValueAMD64_OpDiv16(v *Value) bool {
        // match: (Div16 [a] x y)
        // result: (Select0 (DIVW [a] x y))
        for {
-               a := v.AuxInt
+               a := auxIntToBool(v.AuxInt)
                x := v_0
                y := v_1
                v.reset(OpSelect0)
                v0 := b.NewValue0(v.Pos, OpAMD64DIVW, types.NewTuple(typ.Int16, typ.Int16))
-               v0.AuxInt = a
+               v0.AuxInt = boolToAuxInt(a)
                v0.AddArg2(x, y)
                v.AddArg(v0)
                return true
@@ -29598,12 +29590,12 @@ func rewriteValueAMD64_OpDiv32(v *Value) bool {
        // match: (Div32 [a] x y)
        // result: (Select0 (DIVL [a] x y))
        for {
-               a := v.AuxInt
+               a := auxIntToBool(v.AuxInt)
                x := v_0
                y := v_1
                v.reset(OpSelect0)
                v0 := b.NewValue0(v.Pos, OpAMD64DIVL, types.NewTuple(typ.Int32, typ.Int32))
-               v0.AuxInt = a
+               v0.AuxInt = boolToAuxInt(a)
                v0.AddArg2(x, y)
                v.AddArg(v0)
                return true
@@ -29634,12 +29626,12 @@ func rewriteValueAMD64_OpDiv64(v *Value) bool {
        // match: (Div64 [a] x y)
        // result: (Select0 (DIVQ [a] x y))
        for {
-               a := v.AuxInt
+               a := auxIntToBool(v.AuxInt)
                x := v_0
                y := v_1
                v.reset(OpSelect0)
                v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, types.NewTuple(typ.Int64, typ.Int64))
-               v0.AuxInt = a
+               v0.AuxInt = boolToAuxInt(a)
                v0.AddArg2(x, y)
                v.AddArg(v0)
                return true
@@ -29854,7 +29846,7 @@ func rewriteValueAMD64_OpFloor(v *Value) bool {
        for {
                x := v_0
                v.reset(OpAMD64ROUNDSD)
-               v.AuxInt = 1
+               v.AuxInt = int8ToAuxInt(1)
                v.AddArg(x)
                return true
        }
@@ -30992,12 +30984,12 @@ func rewriteValueAMD64_OpMod16(v *Value) bool {
        // match: (Mod16 [a] x y)
        // result: (Select1 (DIVW [a] x y))
        for {
-               a := v.AuxInt
+               a := auxIntToBool(v.AuxInt)
                x := v_0
                y := v_1
                v.reset(OpSelect1)
                v0 := b.NewValue0(v.Pos, OpAMD64DIVW, types.NewTuple(typ.Int16, typ.Int16))
-               v0.AuxInt = a
+               v0.AuxInt = boolToAuxInt(a)
                v0.AddArg2(x, y)
                v.AddArg(v0)
                return true
@@ -31028,12 +31020,12 @@ func rewriteValueAMD64_OpMod32(v *Value) bool {
        // match: (Mod32 [a] x y)
        // result: (Select1 (DIVL [a] x y))
        for {
-               a := v.AuxInt
+               a := auxIntToBool(v.AuxInt)
                x := v_0
                y := v_1
                v.reset(OpSelect1)
                v0 := b.NewValue0(v.Pos, OpAMD64DIVL, types.NewTuple(typ.Int32, typ.Int32))
-               v0.AuxInt = a
+               v0.AuxInt = boolToAuxInt(a)
                v0.AddArg2(x, y)
                v.AddArg(v0)
                return true
@@ -31064,12 +31056,12 @@ func rewriteValueAMD64_OpMod64(v *Value) bool {
        // match: (Mod64 [a] x y)
        // result: (Select1 (DIVQ [a] x y))
        for {
-               a := v.AuxInt
+               a := auxIntToBool(v.AuxInt)
                x := v_0
                y := v_1
                v.reset(OpSelect1)
                v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, types.NewTuple(typ.Int64, typ.Int64))
-               v0.AuxInt = a
+               v0.AuxInt = boolToAuxInt(a)
                v0.AddArg2(x, y)
                v.AddArg(v0)
                return true
@@ -31626,12 +31618,12 @@ func rewriteValueAMD64_OpNeg32F(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Neg32F x)
-       // result: (PXOR x (MOVSSconst <typ.Float32> [auxFrom32F(float32(math.Copysign(0, -1)))]))
+       // result: (PXOR x (MOVSSconst <typ.Float32> [float32(math.Copysign(0, -1))]))
        for {
                x := v_0
                v.reset(OpAMD64PXOR)
                v0 := b.NewValue0(v.Pos, OpAMD64MOVSSconst, typ.Float32)
-               v0.AuxInt = auxFrom32F(float32(math.Copysign(0, -1)))
+               v0.AuxInt = float32ToAuxInt(float32(math.Copysign(0, -1)))
                v.AddArg2(x, v0)
                return true
        }
@@ -31641,12 +31633,12 @@ func rewriteValueAMD64_OpNeg64F(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Neg64F x)
-       // result: (PXOR x (MOVSDconst <typ.Float64> [auxFrom64F(math.Copysign(0, -1))]))
+       // result: (PXOR x (MOVSDconst <typ.Float64> [math.Copysign(0, -1)]))
        for {
                x := v_0
                v.reset(OpAMD64PXOR)
                v0 := b.NewValue0(v.Pos, OpAMD64MOVSDconst, typ.Float64)
-               v0.AuxInt = auxFrom64F(math.Copysign(0, -1))
+               v0.AuxInt = float64ToAuxInt(math.Copysign(0, -1))
                v.AddArg2(x, v0)
                return true
        }
@@ -31786,7 +31778,7 @@ func rewriteValueAMD64_OpNot(v *Value) bool {
        for {
                x := v_0
                v.reset(OpAMD64XORLconst)
-               v.AuxInt = 1
+               v.AuxInt = int32ToAuxInt(1)
                v.AddArg(x)
                return true
        }
@@ -31797,26 +31789,26 @@ func rewriteValueAMD64_OpOffPtr(v *Value) bool {
        typ := &b.Func.Config.Types
        // match: (OffPtr [off] ptr)
        // cond: is32Bit(off)
-       // result: (ADDQconst [off] ptr)
+       // result: (ADDQconst [int32(off)] ptr)
        for {
-               off := v.AuxInt
+               off := auxIntToInt64(v.AuxInt)
                ptr := v_0
                if !(is32Bit(off)) {
                        break
                }
                v.reset(OpAMD64ADDQconst)
-               v.AuxInt = off
+               v.AuxInt = int32ToAuxInt(int32(off))
                v.AddArg(ptr)
                return true
        }
        // match: (OffPtr [off] ptr)
        // result: (ADDQ (MOVQconst [off]) ptr)
        for {
-               off := v.AuxInt
+               off := auxIntToInt64(v.AuxInt)
                ptr := v_0
                v.reset(OpAMD64ADDQ)
                v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, typ.UInt64)
-               v0.AuxInt = off
+               v0.AuxInt = int64ToAuxInt(off)
                v.AddArg2(v0, ptr)
                return true
        }
@@ -31912,7 +31904,7 @@ func rewriteValueAMD64_OpRoundToEven(v *Value) bool {
        for {
                x := v_0
                v.reset(OpAMD64ROUNDSD)
-               v.AuxInt = 0
+               v.AuxInt = int8ToAuxInt(0)
                v.AddArg(x)
                return true
        }
@@ -33442,7 +33434,7 @@ func rewriteValueAMD64_OpSelect1(v *Value) bool {
                        break
                }
                v_0_0 := v_0.Args[0]
-               if v_0_0.Op != OpAMD64MOVQconst || v_0_0.AuxInt != 0 {
+               if v_0_0.Op != OpAMD64MOVQconst || auxIntToInt64(v_0_0.AuxInt) != 0 {
                        break
                }
                v.reset(OpAMD64FlagEQ)
@@ -33647,7 +33639,7 @@ func rewriteValueAMD64_OpTrunc(v *Value) bool {
        for {
                x := v_0
                v.reset(OpAMD64ROUNDSD)
-               v.AuxInt = 3
+               v.AuxInt = int8ToAuxInt(3)
                v.AddArg(x)
                return true
        }

diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 7cdb78faf9c5fe529379a615dcd52d1cc19e87e4..33c122789e230e6f4cd27ad7f3aa455919520949 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -464,8 +464,7 @@ func rewriteValuegeneric_OpAdd16(v *Value) bool {
                        }
                        d := auxIntToInt16(v_1.AuxInt)
                        v.reset(OpConst16)
-                       var _auxint int16 = c + d
-                       v.AuxInt = int16ToAuxInt(_auxint)
+                       v.AuxInt = int16ToAuxInt(c + d)
                        return true
                }
                break
@@ -718,8 +717,7 @@ func rewriteValuegeneric_OpAdd32(v *Value) bool {
                        }
                        d := auxIntToInt32(v_1.AuxInt)
                        v.reset(OpConst32)
-                       var _auxint int32 = c + d
-                       v.AuxInt = int32ToAuxInt(_auxint)
+                       v.AuxInt = int32ToAuxInt(c + d)
                        return true
                }
                break
@@ -975,8 +973,7 @@ func rewriteValuegeneric_OpAdd32F(v *Value) bool {
                                continue
                        }
                        v.reset(OpConst32F)
-                       var _auxint float32 = c + d
-                       v.AuxInt = float32ToAuxInt(_auxint)
+                       v.AuxInt = float32ToAuxInt(c + d)
                        return true
                }
                break
@@ -1000,8 +997,7 @@ func rewriteValuegeneric_OpAdd64(v *Value) bool {
                        }
                        d := auxIntToInt64(v_1.AuxInt)
                        v.reset(OpConst64)
-                       var _auxint int64 = c + d
-                       v.AuxInt = int64ToAuxInt(_auxint)
+                       v.AuxInt = int64ToAuxInt(c + d)
                        return true
                }
                break
@@ -1257,8 +1253,7 @@ func rewriteValuegeneric_OpAdd64F(v *Value) bool {
                                continue
                        }
                        v.reset(OpConst64F)
-                       var _auxint float64 = c + d
-                       v.AuxInt = float64ToAuxInt(_auxint)
+                       v.AuxInt = float64ToAuxInt(c + d)
                        return true
                }
                break
@@ -1282,8 +1277,7 @@ func rewriteValuegeneric_OpAdd8(v *Value) bool {
                        }
                        d := auxIntToInt8(v_1.AuxInt)
                        v.reset(OpConst8)
-                       var _auxint int8 = c + d
-                       v.AuxInt = int8ToAuxInt(_auxint)
+                       v.AuxInt = int8ToAuxInt(c + d)
                        return true
                }
                break
@@ -1533,8 +1527,7 @@ func rewriteValuegeneric_OpAddPtr(v *Value) bool {
                c := auxIntToInt64(v_1.AuxInt)
                v.reset(OpOffPtr)
                v.Type = t
-               var _auxint int64 = c
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(c)
                v.AddArg(x)
                return true
        }
@@ -1549,8 +1542,7 @@ func rewriteValuegeneric_OpAddPtr(v *Value) bool {
                c := auxIntToInt32(v_1.AuxInt)
                v.reset(OpOffPtr)
                v.Type = t
-               var _auxint int64 = int64(c)
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(c))
                v.AddArg(x)
                return true
        }
@@ -1573,8 +1565,7 @@ func rewriteValuegeneric_OpAnd16(v *Value) bool {
                        }
                        d := auxIntToInt16(v_1.AuxInt)
                        v.reset(OpConst16)
-                       var _auxint int16 = c & d
-                       v.AuxInt = int16ToAuxInt(_auxint)
+                       v.AuxInt = int16ToAuxInt(c & d)
                        return true
                }
                break
@@ -1772,8 +1763,7 @@ func rewriteValuegeneric_OpAnd32(v *Value) bool {
                        }
                        d := auxIntToInt32(v_1.AuxInt)
                        v.reset(OpConst32)
-                       var _auxint int32 = c & d
-                       v.AuxInt = int32ToAuxInt(_auxint)
+                       v.AuxInt = int32ToAuxInt(c & d)
                        return true
                }
                break
@@ -1971,8 +1961,7 @@ func rewriteValuegeneric_OpAnd64(v *Value) bool {
                        }
                        d := auxIntToInt64(v_1.AuxInt)
                        v.reset(OpConst64)
-                       var _auxint int64 = c & d
-                       v.AuxInt = int64ToAuxInt(_auxint)
+                       v.AuxInt = int64ToAuxInt(c & d)
                        return true
                }
                break
@@ -2170,8 +2159,7 @@ func rewriteValuegeneric_OpAnd8(v *Value) bool {
                        }
                        d := auxIntToInt8(v_1.AuxInt)
                        v.reset(OpConst8)
-                       var _auxint int8 = c & d
-                       v.AuxInt = int8ToAuxInt(_auxint)
+                       v.AuxInt = int8ToAuxInt(c & d)
                        return true
                }
                break
@@ -3935,15 +3923,14 @@ func rewriteValuegeneric_OpConstString(v *Value) bool {
        // cond: config.PtrSize == 4 && str == ""
        // result: (StringMake (ConstNil) (Const32 <typ.Int> [0]))
        for {
-               str := v.Aux.(string)
+               str := auxToString(v.Aux)
                if !(config.PtrSize == 4 && str == "") {
                        break
                }
                v.reset(OpStringMake)
                v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr)
                v1 := b.NewValue0(v.Pos, OpConst32, typ.Int)
-               var _auxint int32 = 0
-               v1.AuxInt = int32ToAuxInt(_auxint)
+               v1.AuxInt = int32ToAuxInt(0)
                v.AddArg2(v0, v1)
                return true
        }
@@ -3951,15 +3938,14 @@ func rewriteValuegeneric_OpConstString(v *Value) bool {
        // cond: config.PtrSize == 8 && str == ""
        // result: (StringMake (ConstNil) (Const64 <typ.Int> [0]))
        for {
-               str := v.Aux.(string)
+               str := auxToString(v.Aux)
                if !(config.PtrSize == 8 && str == "") {
                        break
                }
                v.reset(OpStringMake)
                v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr)
                v1 := b.NewValue0(v.Pos, OpConst64, typ.Int)
-               var _auxint int64 = 0
-               v1.AuxInt = int64ToAuxInt(_auxint)
+               v1.AuxInt = int64ToAuxInt(0)
                v.AddArg2(v0, v1)
                return true
        }
@@ -3967,19 +3953,17 @@ func rewriteValuegeneric_OpConstString(v *Value) bool {
        // cond: config.PtrSize == 4 && str != ""
        // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(str)} (SB)) (Const32 <typ.Int> [int32(len(str))]))
        for {
-               str := v.Aux.(string)
+               str := auxToString(v.Aux)
                if !(config.PtrSize == 4 && str != "") {
                        break
                }
                v.reset(OpStringMake)
                v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr)
-               var _aux Sym = fe.StringData(str)
-               v0.Aux = _aux
+               v0.Aux = symToAux(fe.StringData(str))
                v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr)
                v0.AddArg(v1)
                v2 := b.NewValue0(v.Pos, OpConst32, typ.Int)
-               var _auxint int32 = int32(len(str))
-               v2.AuxInt = int32ToAuxInt(_auxint)
+               v2.AuxInt = int32ToAuxInt(int32(len(str)))
                v.AddArg2(v0, v2)
                return true
        }
@@ -3987,19 +3971,17 @@ func rewriteValuegeneric_OpConstString(v *Value) bool {
        // cond: config.PtrSize == 8 && str != ""
        // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(str)} (SB)) (Const64 <typ.Int> [int64(len(str))]))
        for {
-               str := v.Aux.(string)
+               str := auxToString(v.Aux)
                if !(config.PtrSize == 8 && str != "") {
                        break
                }
                v.reset(OpStringMake)
                v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr)
-               var _aux Sym = fe.StringData(str)
-               v0.Aux = _aux
+               v0.Aux = symToAux(fe.StringData(str))
                v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr)
                v0.AddArg(v1)
                v2 := b.NewValue0(v.Pos, OpConst64, typ.Int)
-               var _auxint int64 = int64(len(str))
-               v2.AuxInt = int64ToAuxInt(_auxint)
+               v2.AuxInt = int64ToAuxInt(int64(len(str)))
                v.AddArg2(v0, v2)
                return true
        }
@@ -4090,8 +4072,7 @@ func rewriteValuegeneric_OpCtz16(v *Value) bool {
                        break
                }
                v.reset(OpConst32)
-               var _auxint int32 = int32(ntz16(c))
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(ntz16(c)))
                return true
        }
        // match: (Ctz16 (Const16 [c]))
@@ -4106,8 +4087,7 @@ func rewriteValuegeneric_OpCtz16(v *Value) bool {
                        break
                }
                v.reset(OpConst64)
-               var _auxint int64 = int64(ntz16(c))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(ntz16(c)))
                return true
        }
        return false
@@ -4128,8 +4108,7 @@ func rewriteValuegeneric_OpCtz32(v *Value) bool {
                        break
                }
                v.reset(OpConst32)
-               var _auxint int32 = int32(ntz32(c))
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(ntz32(c)))
                return true
        }
        // match: (Ctz32 (Const32 [c]))
@@ -4144,8 +4123,7 @@ func rewriteValuegeneric_OpCtz32(v *Value) bool {
                        break
                }
                v.reset(OpConst64)
-               var _auxint int64 = int64(ntz32(c))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(ntz32(c)))
                return true
        }
        return false
@@ -4166,8 +4144,7 @@ func rewriteValuegeneric_OpCtz64(v *Value) bool {
                        break
                }
                v.reset(OpConst32)
-               var _auxint int32 = int32(ntz64(c))
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(ntz64(c)))
                return true
        }
        // match: (Ctz64 (Const64 [c]))
@@ -4182,8 +4159,7 @@ func rewriteValuegeneric_OpCtz64(v *Value) bool {
                        break
                }
                v.reset(OpConst64)
-               var _auxint int64 = int64(ntz64(c))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(ntz64(c)))
                return true
        }
        return false
@@ -4204,8 +4180,7 @@ func rewriteValuegeneric_OpCtz8(v *Value) bool {
                        break
                }
                v.reset(OpConst32)
-               var _auxint int32 = int32(ntz8(c))
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(ntz8(c)))
                return true
        }
        // match: (Ctz8 (Const8 [c]))
@@ -4220,8 +4195,7 @@ func rewriteValuegeneric_OpCtz8(v *Value) bool {
                        break
                }
                v.reset(OpConst64)
-               var _auxint int64 = int64(ntz8(c))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(ntz8(c)))
                return true
        }
        return false
@@ -4236,8 +4210,7 @@ func rewriteValuegeneric_OpCvt32Fto32(v *Value) bool {
                }
                c := auxIntToFloat32(v_0.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = int32(c)
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(c))
                return true
        }
        return false
@@ -4252,8 +4225,7 @@ func rewriteValuegeneric_OpCvt32Fto64(v *Value) bool {
                }
                c := auxIntToFloat32(v_0.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = int64(c)
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(c))
                return true
        }
        return false
@@ -4268,8 +4240,7 @@ func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool {
                }
                c := auxIntToFloat32(v_0.AuxInt)
                v.reset(OpConst64F)
-               var _auxint float64 = float64(c)
-               v.AuxInt = float64ToAuxInt(_auxint)
+               v.AuxInt = float64ToAuxInt(float64(c))
                return true
        }
        return false
@@ -4284,8 +4255,7 @@ func rewriteValuegeneric_OpCvt32to32F(v *Value) bool {
                }
                c := auxIntToInt32(v_0.AuxInt)
                v.reset(OpConst32F)
-               var _auxint float32 = float32(c)
-               v.AuxInt = float32ToAuxInt(_auxint)
+               v.AuxInt = float32ToAuxInt(float32(c))
                return true
        }
        return false
@@ -4300,8 +4270,7 @@ func rewriteValuegeneric_OpCvt32to64F(v *Value) bool {
                }
                c := auxIntToInt32(v_0.AuxInt)
                v.reset(OpConst64F)
-               var _auxint float64 = float64(c)
-               v.AuxInt = float64ToAuxInt(_auxint)
+               v.AuxInt = float64ToAuxInt(float64(c))
                return true
        }
        return false
@@ -4316,8 +4285,7 @@ func rewriteValuegeneric_OpCvt64Fto32(v *Value) bool {
                }
                c := auxIntToFloat64(v_0.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = int32(c)
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(c))
                return true
        }
        return false
@@ -4332,8 +4300,7 @@ func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool {
                }
                c := auxIntToFloat64(v_0.AuxInt)
                v.reset(OpConst32F)
-               var _auxint float32 = float32(c)
-               v.AuxInt = float32ToAuxInt(_auxint)
+               v.AuxInt = float32ToAuxInt(float32(c))
                return true
        }
        return false
@@ -4348,8 +4315,7 @@ func rewriteValuegeneric_OpCvt64Fto64(v *Value) bool {
                }
                c := auxIntToFloat64(v_0.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = int64(c)
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(c))
                return true
        }
        return false
@@ -4364,8 +4330,7 @@ func rewriteValuegeneric_OpCvt64to32F(v *Value) bool {
                }
                c := auxIntToInt64(v_0.AuxInt)
                v.reset(OpConst32F)
-               var _auxint float32 = float32(c)
-               v.AuxInt = float32ToAuxInt(_auxint)
+               v.AuxInt = float32ToAuxInt(float32(c))
                return true
        }
        return false
@@ -4380,8 +4345,7 @@ func rewriteValuegeneric_OpCvt64to64F(v *Value) bool {
                }
                c := auxIntToInt64(v_0.AuxInt)
                v.reset(OpConst64F)
-               var _auxint float64 = float64(c)
-               v.AuxInt = float64ToAuxInt(_auxint)
+               v.AuxInt = float64ToAuxInt(float64(c))
                return true
        }
        return false
@@ -4395,8 +4359,7 @@ func rewriteValuegeneric_OpCvtBoolToUint8(v *Value) bool {
                        break
                }
                v.reset(OpConst8)
-               var _auxint int8 = 0
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(0)
                return true
        }
        // match: (CvtBoolToUint8 (ConstBool [true]))
@@ -4406,8 +4369,7 @@ func rewriteValuegeneric_OpCvtBoolToUint8(v *Value) bool {
                        break
                }
                v.reset(OpConst8)
-               var _auxint int8 = 1
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(1)
                return true
        }
        return false
@@ -4433,8 +4395,7 @@ func rewriteValuegeneric_OpDiv16(v *Value) bool {
                        break
                }
                v.reset(OpConst16)
-               var _auxint int16 = c / d
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(c / d)
                return true
        }
        // match: (Div16 n (Const16 [c]))
@@ -4581,8 +4542,7 @@ func rewriteValuegeneric_OpDiv16u(v *Value) bool {
                        break
                }
                v.reset(OpConst16)
-               var _auxint int16 = int16(uint16(c) / uint16(d))
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(int16(uint16(c) / uint16(d)))
                return true
        }
        // match: (Div16u n (Const16 [c]))
@@ -4743,8 +4703,7 @@ func rewriteValuegeneric_OpDiv32(v *Value) bool {
                        break
                }
                v.reset(OpConst32)
-               var _auxint int32 = c / d
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(c / d)
                return true
        }
        // match: (Div32 n (Const32 [c]))
@@ -4951,8 +4910,7 @@ func rewriteValuegeneric_OpDiv32F(v *Value) bool {
                        break
                }
                v.reset(OpConst32F)
-               var _auxint float32 = c / d
-               v.AuxInt = float32ToAuxInt(_auxint)
+               v.AuxInt = float32ToAuxInt(c / d)
                return true
        }
        // match: (Div32F x (Const32F <t> [c]))
@@ -4998,8 +4956,7 @@ func rewriteValuegeneric_OpDiv32u(v *Value) bool {
                        break
                }
                v.reset(OpConst32)
-               var _auxint int32 = int32(uint32(c) / uint32(d))
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(uint32(c) / uint32(d)))
                return true
        }
        // match: (Div32u n (Const32 [c]))
@@ -5209,8 +5166,7 @@ func rewriteValuegeneric_OpDiv64(v *Value) bool {
                        break
                }
                v.reset(OpConst64)
-               var _auxint int64 = c / d
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(c / d)
                return true
        }
        // match: (Div64 n (Const64 [c]))
@@ -5395,8 +5351,7 @@ func rewriteValuegeneric_OpDiv64F(v *Value) bool {
                        break
                }
                v.reset(OpConst64F)
-               var _auxint float64 = c / d
-               v.AuxInt = float64ToAuxInt(_auxint)
+               v.AuxInt = float64ToAuxInt(c / d)
                return true
        }
        // match: (Div64F x (Const64F <t> [c]))
@@ -5442,8 +5397,7 @@ func rewriteValuegeneric_OpDiv64u(v *Value) bool {
                        break
                }
                v.reset(OpConst64)
-               var _auxint int64 = int64(uint64(c) / uint64(d))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(uint64(c) / uint64(d)))
                return true
        }
        // match: (Div64u n (Const64 [c]))
@@ -5575,8 +5529,7 @@ func rewriteValuegeneric_OpDiv8(v *Value) bool {
                        break
                }
                v.reset(OpConst8)
-               var _auxint int8 = c / d
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(c / d)
                return true
        }
        // match: (Div8 n (Const8 [c]))
@@ -5722,8 +5675,7 @@ func rewriteValuegeneric_OpDiv8u(v *Value) bool {
                        break
                }
                v.reset(OpConst8)
-               var _auxint int8 = int8(uint8(c) / uint8(d))
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(int8(uint8(c) / uint8(d)))
                return true
        }
        // match: (Div8u n (Const8 [c]))
@@ -5786,8 +5738,7 @@ func rewriteValuegeneric_OpEq16(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (Eq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
@@ -6410,8 +6361,7 @@ func rewriteValuegeneric_OpEq32(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (Eq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
@@ -7298,8 +7248,7 @@ func rewriteValuegeneric_OpEq64(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (Eq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
@@ -7881,8 +7830,7 @@ func rewriteValuegeneric_OpEq8(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (Eq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
@@ -8283,8 +8231,7 @@ func rewriteValuegeneric_OpEqB(v *Value) bool {
                        }
                        d := auxIntToBool(v_1.AuxInt)
                        v.reset(OpConstBool)
-                       var _auxint bool = c == d
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(c == d)
                        return true
                }
                break
@@ -8819,8 +8766,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (ZeroExt8to64 _) (Const64 [c]))
@@ -8835,8 +8781,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (ZeroExt16to32 _) (Const32 [c]))
@@ -8851,8 +8796,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (ZeroExt16to64 _) (Const64 [c]))
@@ -8867,8 +8811,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds x x)
@@ -8879,8 +8822,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = false
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(false)
                return true
        }
        // match: (IsInBounds (And8 (Const8 [c]) _) (Const8 [d]))
@@ -8905,8 +8847,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -8937,8 +8878,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -8969,8 +8909,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9001,8 +8940,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9029,8 +8967,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9061,8 +8998,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9093,8 +9029,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9121,8 +9056,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9153,8 +9087,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9181,8 +9114,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9199,8 +9131,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                }
                d := auxIntToInt32(v_1.AuxInt)
                v.reset(OpConstBool)
-               var _auxint bool = 0 <= c && c < d
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(0 <= c && c < d)
                return true
        }
        // match: (IsInBounds (Const64 [c]) (Const64 [d]))
@@ -9215,8 +9146,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConstBool)
-               var _auxint bool = 0 <= c && c < d
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(0 <= c && c < d)
                return true
        }
        // match: (IsInBounds (Mod32u _ y) y)
@@ -9230,8 +9160,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (Mod64u _ y) y)
@@ -9245,8 +9174,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (ZeroExt8to64 (Rsh8Ux64 _ (Const64 [c]))) (Const64 [d]))
@@ -9274,8 +9202,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (ZeroExt8to32 (Rsh8Ux64 _ (Const64 [c]))) (Const32 [d]))
@@ -9303,8 +9230,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (ZeroExt8to16 (Rsh8Ux64 _ (Const64 [c]))) (Const16 [d]))
@@ -9332,8 +9258,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (Rsh8Ux64 _ (Const64 [c])) (Const64 [d]))
@@ -9357,8 +9282,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (ZeroExt16to64 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d]))
@@ -9386,8 +9310,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (ZeroExt16to32 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d]))
@@ -9415,8 +9338,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (Rsh16Ux64 _ (Const64 [c])) (Const64 [d]))
@@ -9440,8 +9362,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (ZeroExt32to64 (Rsh32Ux64 _ (Const64 [c]))) (Const64 [d]))
@@ -9469,8 +9390,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (Rsh32Ux64 _ (Const64 [c])) (Const64 [d]))
@@ -9494,8 +9414,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsInBounds (Rsh64Ux64 _ (Const64 [c])) (Const64 [d]))
@@ -9519,8 +9438,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        return false
@@ -9592,8 +9510,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsSliceInBounds (And32 (Const32 [c]) _) (Const32 [d]))
@@ -9618,8 +9535,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9646,8 +9562,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
                                continue
                        }
                        v.reset(OpConstBool)
-                       var _auxint bool = true
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(true)
                        return true
                }
                break
@@ -9659,8 +9574,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsSliceInBounds (Const64 [0]) _)
@@ -9670,8 +9584,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        // match: (IsSliceInBounds (Const32 [c]) (Const32 [d]))
@@ -9686,8 +9599,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
                }
                d := auxIntToInt32(v_1.AuxInt)
                v.reset(OpConstBool)
-               var _auxint bool = 0 <= c && c <= d
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(0 <= c && c <= d)
                return true
        }
        // match: (IsSliceInBounds (Const64 [c]) (Const64 [d]))
@@ -9702,8 +9614,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConstBool)
-               var _auxint bool = 0 <= c && c <= d
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(0 <= c && c <= d)
                return true
        }
        // match: (IsSliceInBounds (SliceLen x) (SliceCap x))
@@ -9717,8 +9628,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = true
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(true)
                return true
        }
        return false
@@ -11075,8 +10985,7 @@ func rewriteValuegeneric_OpLsh16x64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst16)
-               var _auxint int16 = c << uint64(d)
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(c << uint64(d))
                return true
        }
        // match: (Lsh16x64 x (Const64 [0]))
@@ -11291,8 +11200,7 @@ func rewriteValuegeneric_OpLsh32x64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = c << uint64(d)
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(c << uint64(d))
                return true
        }
        // match: (Lsh32x64 x (Const64 [0]))
@@ -11507,8 +11415,7 @@ func rewriteValuegeneric_OpLsh64x64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = c << uint64(d)
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(c << uint64(d))
                return true
        }
        // match: (Lsh64x64 x (Const64 [0]))
@@ -11723,8 +11630,7 @@ func rewriteValuegeneric_OpLsh8x64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst8)
-               var _auxint int8 = c << uint64(d)
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(c << uint64(d))
                return true
        }
        // match: (Lsh8x64 x (Const64 [0]))
@@ -11880,8 +11786,7 @@ func rewriteValuegeneric_OpMod16(v *Value) bool {
                        break
                }
                v.reset(OpConst16)
-               var _auxint int16 = c % d
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(c % d)
                return true
        }
        // match: (Mod16 <t> n (Const16 [c]))
@@ -11970,8 +11875,7 @@ func rewriteValuegeneric_OpMod16u(v *Value) bool {
                        break
                }
                v.reset(OpConst16)
-               var _auxint int16 = int16(uint16(c) % uint16(d))
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(int16(uint16(c) % uint16(d)))
                return true
        }
        // match: (Mod16u <t> n (Const16 [c]))
@@ -12040,8 +11944,7 @@ func rewriteValuegeneric_OpMod32(v *Value) bool {
                        break
                }
                v.reset(OpConst32)
-               var _auxint int32 = c % d
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(c % d)
                return true
        }
        // match: (Mod32 <t> n (Const32 [c]))
@@ -12130,8 +12033,7 @@ func rewriteValuegeneric_OpMod32u(v *Value) bool {
                        break
                }
                v.reset(OpConst32)
-               var _auxint int32 = int32(uint32(c) % uint32(d))
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(uint32(c) % uint32(d)))
                return true
        }
        // match: (Mod32u <t> n (Const32 [c]))
@@ -12200,8 +12102,7 @@ func rewriteValuegeneric_OpMod64(v *Value) bool {
                        break
                }
                v.reset(OpConst64)
-               var _auxint int64 = c % d
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(c % d)
                return true
        }
        // match: (Mod64 <t> n (Const64 [c]))
@@ -12301,8 +12202,7 @@ func rewriteValuegeneric_OpMod64u(v *Value) bool {
                        break
                }
                v.reset(OpConst64)
-               var _auxint int64 = int64(uint64(c) % uint64(d))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(uint64(c) % uint64(d)))
                return true
        }
        // match: (Mod64u <t> n (Const64 [c]))
@@ -12385,8 +12285,7 @@ func rewriteValuegeneric_OpMod8(v *Value) bool {
                        break
                }
                v.reset(OpConst8)
-               var _auxint int8 = c % d
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(c % d)
                return true
        }
        // match: (Mod8 <t> n (Const8 [c]))
@@ -12475,8 +12374,7 @@ func rewriteValuegeneric_OpMod8u(v *Value) bool {
                        break
                }
                v.reset(OpConst8)
-               var _auxint int8 = int8(uint8(c) % uint8(d))
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(int8(uint8(c) % uint8(d)))
                return true
        }
        // match: (Mod8u <t> n (Const8 [c]))
@@ -13857,8 +13755,7 @@ func rewriteValuegeneric_OpMul16(v *Value) bool {
                        }
                        d := auxIntToInt16(v_1.AuxInt)
                        v.reset(OpConst16)
-                       var _auxint int16 = c * d
-                       v.AuxInt = int16ToAuxInt(_auxint)
+                       v.AuxInt = int16ToAuxInt(c * d)
                        return true
                }
                break
@@ -13907,8 +13804,7 @@ func rewriteValuegeneric_OpMul16(v *Value) bool {
                        v.reset(OpLsh16x64)
                        v.Type = t
                        v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
-                       var _auxint int64 = log16(c)
-                       v0.AuxInt = int64ToAuxInt(_auxint)
+                       v0.AuxInt = int64ToAuxInt(log16(c))
                        v.AddArg2(n, v0)
                        return true
                }
@@ -13931,8 +13827,7 @@ func rewriteValuegeneric_OpMul16(v *Value) bool {
                        v.reset(OpNeg16)
                        v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
                        v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
-                       var _auxint int64 = log16(-c)
-                       v1.AuxInt = int64ToAuxInt(_auxint)
+                       v1.AuxInt = int64ToAuxInt(log16(-c))
                        v0.AddArg2(n, v1)
                        v.AddArg(v0)
                        return true
@@ -14002,8 +13897,7 @@ func rewriteValuegeneric_OpMul32(v *Value) bool {
                        }
                        d := auxIntToInt32(v_1.AuxInt)
                        v.reset(OpConst32)
-                       var _auxint int32 = c * d
-                       v.AuxInt = int32ToAuxInt(_auxint)
+                       v.AuxInt = int32ToAuxInt(c * d)
                        return true
                }
                break
@@ -14052,8 +13946,7 @@ func rewriteValuegeneric_OpMul32(v *Value) bool {
                        v.reset(OpLsh32x64)
                        v.Type = t
                        v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
-                       var _auxint int64 = log32(c)
-                       v0.AuxInt = int64ToAuxInt(_auxint)
+                       v0.AuxInt = int64ToAuxInt(log32(c))
                        v.AddArg2(n, v0)
                        return true
                }
@@ -14076,8 +13969,7 @@ func rewriteValuegeneric_OpMul32(v *Value) bool {
                        v.reset(OpNeg32)
                        v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
                        v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
-                       var _auxint int64 = log32(-c)
-                       v1.AuxInt = int64ToAuxInt(_auxint)
+                       v1.AuxInt = int64ToAuxInt(log32(-c))
                        v0.AddArg2(n, v1)
                        v.AddArg(v0)
                        return true
@@ -14183,8 +14075,7 @@ func rewriteValuegeneric_OpMul32F(v *Value) bool {
                                continue
                        }
                        v.reset(OpConst32F)
-                       var _auxint float32 = c * d
-                       v.AuxInt = float32ToAuxInt(_auxint)
+                       v.AuxInt = float32ToAuxInt(c * d)
                        return true
                }
                break
@@ -14250,8 +14141,7 @@ func rewriteValuegeneric_OpMul64(v *Value) bool {
                        }
                        d := auxIntToInt64(v_1.AuxInt)
                        v.reset(OpConst64)
-                       var _auxint int64 = c * d
-                       v.AuxInt = int64ToAuxInt(_auxint)
+                       v.AuxInt = int64ToAuxInt(c * d)
                        return true
                }
                break
@@ -14300,8 +14190,7 @@ func rewriteValuegeneric_OpMul64(v *Value) bool {
                        v.reset(OpLsh64x64)
                        v.Type = t
                        v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
-                       var _auxint int64 = log64(c)
-                       v0.AuxInt = int64ToAuxInt(_auxint)
+                       v0.AuxInt = int64ToAuxInt(log64(c))
                        v.AddArg2(n, v0)
                        return true
                }
@@ -14324,8 +14213,7 @@ func rewriteValuegeneric_OpMul64(v *Value) bool {
                        v.reset(OpNeg64)
                        v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
                        v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
-                       var _auxint int64 = log64(-c)
-                       v1.AuxInt = int64ToAuxInt(_auxint)
+                       v1.AuxInt = int64ToAuxInt(log64(-c))
                        v0.AddArg2(n, v1)
                        v.AddArg(v0)
                        return true
@@ -14431,8 +14319,7 @@ func rewriteValuegeneric_OpMul64F(v *Value) bool {
                                continue
                        }
                        v.reset(OpConst64F)
-                       var _auxint float64 = c * d
-                       v.AuxInt = float64ToAuxInt(_auxint)
+                       v.AuxInt = float64ToAuxInt(c * d)
                        return true
                }
                break
@@ -14498,8 +14385,7 @@ func rewriteValuegeneric_OpMul8(v *Value) bool {
                        }
                        d := auxIntToInt8(v_1.AuxInt)
                        v.reset(OpConst8)
-                       var _auxint int8 = c * d
-                       v.AuxInt = int8ToAuxInt(_auxint)
+                       v.AuxInt = int8ToAuxInt(c * d)
                        return true
                }
                break
@@ -14548,8 +14434,7 @@ func rewriteValuegeneric_OpMul8(v *Value) bool {
                        v.reset(OpLsh8x64)
                        v.Type = t
                        v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
-                       var _auxint int64 = log8(c)
-                       v0.AuxInt = int64ToAuxInt(_auxint)
+                       v0.AuxInt = int64ToAuxInt(log8(c))
                        v.AddArg2(n, v0)
                        return true
                }
@@ -14572,8 +14457,7 @@ func rewriteValuegeneric_OpMul8(v *Value) bool {
                        v.reset(OpNeg8)
                        v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
                        v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
-                       var _auxint int64 = log8(-c)
-                       v1.AuxInt = int64ToAuxInt(_auxint)
+                       v1.AuxInt = int64ToAuxInt(log8(-c))
                        v0.AddArg2(n, v1)
                        v.AddArg(v0)
                        return true
@@ -14636,8 +14520,7 @@ func rewriteValuegeneric_OpNeg16(v *Value) bool {
                }
                c := auxIntToInt16(v_0.AuxInt)
                v.reset(OpConst16)
-               var _auxint int16 = -c
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(-c)
                return true
        }
        // match: (Neg16 (Sub16 x y))
@@ -14689,8 +14572,7 @@ func rewriteValuegeneric_OpNeg32(v *Value) bool {
                }
                c := auxIntToInt32(v_0.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = -c
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(-c)
                return true
        }
        // match: (Neg32 (Sub32 x y))
@@ -14745,8 +14627,7 @@ func rewriteValuegeneric_OpNeg32F(v *Value) bool {
                        break
                }
                v.reset(OpConst32F)
-               var _auxint float32 = -c
-               v.AuxInt = float32ToAuxInt(_auxint)
+               v.AuxInt = float32ToAuxInt(-c)
                return true
        }
        return false
@@ -14762,8 +14643,7 @@ func rewriteValuegeneric_OpNeg64(v *Value) bool {
                }
                c := auxIntToInt64(v_0.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = -c
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(-c)
                return true
        }
        // match: (Neg64 (Sub64 x y))
@@ -14818,8 +14698,7 @@ func rewriteValuegeneric_OpNeg64F(v *Value) bool {
                        break
                }
                v.reset(OpConst64F)
-               var _auxint float64 = -c
-               v.AuxInt = float64ToAuxInt(_auxint)
+               v.AuxInt = float64ToAuxInt(-c)
                return true
        }
        return false
@@ -14835,8 +14714,7 @@ func rewriteValuegeneric_OpNeg8(v *Value) bool {
                }
                c := auxIntToInt8(v_0.AuxInt)
                v.reset(OpConst8)
-               var _auxint int8 = -c
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(-c)
                return true
        }
        // match: (Neg8 (Sub8 x y))
@@ -14890,8 +14768,7 @@ func rewriteValuegeneric_OpNeq16(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = false
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(false)
                return true
        }
        // match: (Neq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
@@ -15078,8 +14955,7 @@ func rewriteValuegeneric_OpNeq32(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = false
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(false)
                return true
        }
        // match: (Neq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
@@ -15289,8 +15165,7 @@ func rewriteValuegeneric_OpNeq64(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = false
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(false)
                return true
        }
        // match: (Neq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
@@ -15500,8 +15375,7 @@ func rewriteValuegeneric_OpNeq8(v *Value) bool {
                        break
                }
                v.reset(OpConstBool)
-               var _auxint bool = false
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(false)
                return true
        }
        // match: (Neq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
@@ -15691,8 +15565,7 @@ func rewriteValuegeneric_OpNeqB(v *Value) bool {
                        }
                        d := auxIntToBool(v_1.AuxInt)
                        v.reset(OpConstBool)
-                       var _auxint bool = c != d
-                       v.AuxInt = boolToAuxInt(_auxint)
+                       v.AuxInt = boolToAuxInt(c != d)
                        return true
                }
                break
@@ -16237,8 +16110,7 @@ func rewriteValuegeneric_OpNot(v *Value) bool {
                }
                c := auxIntToBool(v_0.AuxInt)
                v.reset(OpConstBool)
-               var _auxint bool = !c
-               v.AuxInt = boolToAuxInt(_auxint)
+               v.AuxInt = boolToAuxInt(!c)
                return true
        }
        // match: (Not (Eq64 x y))
@@ -16676,8 +16548,7 @@ func rewriteValuegeneric_OpOr16(v *Value) bool {
                        }
                        d := auxIntToInt16(v_1.AuxInt)
                        v.reset(OpConst16)
-                       var _auxint int16 = c | d
-                       v.AuxInt = int16ToAuxInt(_auxint)
+                       v.AuxInt = int16ToAuxInt(c | d)
                        return true
                }
                break
@@ -16855,8 +16726,7 @@ func rewriteValuegeneric_OpOr32(v *Value) bool {
                        }
                        d := auxIntToInt32(v_1.AuxInt)
                        v.reset(OpConst32)
-                       var _auxint int32 = c | d
-                       v.AuxInt = int32ToAuxInt(_auxint)
+                       v.AuxInt = int32ToAuxInt(c | d)
                        return true
                }
                break
@@ -17034,8 +16904,7 @@ func rewriteValuegeneric_OpOr64(v *Value) bool {
                        }
                        d := auxIntToInt64(v_1.AuxInt)
                        v.reset(OpConst64)
-                       var _auxint int64 = c | d
-                       v.AuxInt = int64ToAuxInt(_auxint)
+                       v.AuxInt = int64ToAuxInt(c | d)
                        return true
                }
                break
@@ -17213,8 +17082,7 @@ func rewriteValuegeneric_OpOr8(v *Value) bool {
                        }
                        d := auxIntToInt8(v_1.AuxInt)
                        v.reset(OpConst8)
-                       var _auxint int8 = c | d
-                       v.AuxInt = int8ToAuxInt(_auxint)
+                       v.AuxInt = int8ToAuxInt(c | d)
                        return true
                }
                break
@@ -18995,8 +18863,7 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst16)
-               var _auxint int16 = int16(uint16(c) >> uint64(d))
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(int16(uint16(c) >> uint64(d)))
                return true
        }
        // match: (Rsh16Ux64 x (Const64 [0]))
@@ -19249,8 +19116,7 @@ func rewriteValuegeneric_OpRsh16x64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst16)
-               var _auxint int16 = c >> uint64(d)
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(c >> uint64(d))
                return true
        }
        // match: (Rsh16x64 x (Const64 [0]))
@@ -19431,8 +19297,7 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = int32(uint32(c) >> uint64(d))
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
                return true
        }
        // match: (Rsh32Ux64 x (Const64 [0]))
@@ -19703,8 +19568,7 @@ func rewriteValuegeneric_OpRsh32x64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = c >> uint64(d)
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(c >> uint64(d))
                return true
        }
        // match: (Rsh32x64 x (Const64 [0]))
@@ -19903,8 +19767,7 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = int64(uint64(c) >> uint64(d))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
                return true
        }
        // match: (Rsh64Ux64 x (Const64 [0]))
@@ -20193,8 +20056,7 @@ func rewriteValuegeneric_OpRsh64x64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = c >> uint64(d)
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(c >> uint64(d))
                return true
        }
        // match: (Rsh64x64 x (Const64 [0]))
@@ -20411,8 +20273,7 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst8)
-               var _auxint int8 = int8(uint8(c) >> uint64(d))
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(int8(uint8(c) >> uint64(d)))
                return true
        }
        // match: (Rsh8Ux64 x (Const64 [0]))
@@ -20646,8 +20507,7 @@ func rewriteValuegeneric_OpRsh8x64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst8)
-               var _auxint int8 = c >> uint64(d)
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(c >> uint64(d))
                return true
        }
        // match: (Rsh8x64 x (Const64 [0]))
@@ -20781,8 +20641,7 @@ func rewriteValuegeneric_OpSignExt16to32(v *Value) bool {
                }
                c := auxIntToInt16(v_0.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = int32(c)
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(c))
                return true
        }
        // match: (SignExt16to32 (Trunc32to16 x:(Rsh32x64 _ (Const64 [s]))))
@@ -20820,8 +20679,7 @@ func rewriteValuegeneric_OpSignExt16to64(v *Value) bool {
                }
                c := auxIntToInt16(v_0.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = int64(c)
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(c))
                return true
        }
        // match: (SignExt16to64 (Trunc64to16 x:(Rsh64x64 _ (Const64 [s]))))
@@ -20859,8 +20717,7 @@ func rewriteValuegeneric_OpSignExt32to64(v *Value) bool {
                }
                c := auxIntToInt32(v_0.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = int64(c)
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(c))
                return true
        }
        // match: (SignExt32to64 (Trunc64to32 x:(Rsh64x64 _ (Const64 [s]))))
@@ -20898,8 +20755,7 @@ func rewriteValuegeneric_OpSignExt8to16(v *Value) bool {
                }
                c := auxIntToInt8(v_0.AuxInt)
                v.reset(OpConst16)
-               var _auxint int16 = int16(c)
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(int16(c))
                return true
        }
        // match: (SignExt8to16 (Trunc16to8 x:(Rsh16x64 _ (Const64 [s]))))
@@ -20937,8 +20793,7 @@ func rewriteValuegeneric_OpSignExt8to32(v *Value) bool {
                }
                c := auxIntToInt8(v_0.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = int32(c)
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(c))
                return true
        }
        // match: (SignExt8to32 (Trunc32to8 x:(Rsh32x64 _ (Const64 [s]))))
@@ -20976,8 +20831,7 @@ func rewriteValuegeneric_OpSignExt8to64(v *Value) bool {
                }
                c := auxIntToInt8(v_0.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = int64(c)
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(c))
                return true
        }
        // match: (SignExt8to64 (Trunc64to8 x:(Rsh64x64 _ (Const64 [s]))))
@@ -22374,8 +22228,7 @@ func rewriteValuegeneric_OpSub16(v *Value) bool {
                }
                d := auxIntToInt16(v_1.AuxInt)
                v.reset(OpConst16)
-               var _auxint int16 = c - d
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(c - d)
                return true
        }
        // match: (Sub16 x (Const16 <t> [c]))
@@ -22593,8 +22446,7 @@ func rewriteValuegeneric_OpSub32(v *Value) bool {
                }
                d := auxIntToInt32(v_1.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = c - d
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(c - d)
                return true
        }
        // match: (Sub32 x (Const32 <t> [c]))
@@ -22815,8 +22667,7 @@ func rewriteValuegeneric_OpSub32F(v *Value) bool {
                        break
                }
                v.reset(OpConst32F)
-               var _auxint float32 = c - d
-               v.AuxInt = float32ToAuxInt(_auxint)
+               v.AuxInt = float32ToAuxInt(c - d)
                return true
        }
        return false
@@ -22837,8 +22688,7 @@ func rewriteValuegeneric_OpSub64(v *Value) bool {
                }
                d := auxIntToInt64(v_1.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = c - d
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(c - d)
                return true
        }
        // match: (Sub64 x (Const64 <t> [c]))
@@ -23059,8 +22909,7 @@ func rewriteValuegeneric_OpSub64F(v *Value) bool {
                        break
                }
                v.reset(OpConst64F)
-               var _auxint float64 = c - d
-               v.AuxInt = float64ToAuxInt(_auxint)
+               v.AuxInt = float64ToAuxInt(c - d)
                return true
        }
        return false
@@ -23081,8 +22930,7 @@ func rewriteValuegeneric_OpSub8(v *Value) bool {
                }
                d := auxIntToInt8(v_1.AuxInt)
                v.reset(OpConst8)
-               var _auxint int8 = c - d
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(c - d)
                return true
        }
        // match: (Sub8 x (Const8 <t> [c]))
@@ -23294,8 +23142,7 @@ func rewriteValuegeneric_OpTrunc16to8(v *Value) bool {
                }
                c := auxIntToInt16(v_0.AuxInt)
                v.reset(OpConst8)
-               var _auxint int8 = int8(c)
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(int8(c))
                return true
        }
        // match: (Trunc16to8 (ZeroExt8to16 x))
@@ -23355,8 +23202,7 @@ func rewriteValuegeneric_OpTrunc32to16(v *Value) bool {
                }
                c := auxIntToInt32(v_0.AuxInt)
                v.reset(OpConst16)
-               var _auxint int16 = int16(c)
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(int16(c))
                return true
        }
        // match: (Trunc32to16 (ZeroExt8to32 x))
@@ -23438,8 +23284,7 @@ func rewriteValuegeneric_OpTrunc32to8(v *Value) bool {
                }
                c := auxIntToInt32(v_0.AuxInt)
                v.reset(OpConst8)
-               var _auxint int8 = int8(c)
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(int8(c))
                return true
        }
        // match: (Trunc32to8 (ZeroExt8to32 x))
@@ -23499,8 +23344,7 @@ func rewriteValuegeneric_OpTrunc64to16(v *Value) bool {
                }
                c := auxIntToInt64(v_0.AuxInt)
                v.reset(OpConst16)
-               var _auxint int16 = int16(c)
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(int16(c))
                return true
        }
        // match: (Trunc64to16 (ZeroExt8to64 x))
@@ -23582,8 +23426,7 @@ func rewriteValuegeneric_OpTrunc64to32(v *Value) bool {
                }
                c := auxIntToInt64(v_0.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = int32(c)
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(c))
                return true
        }
        // match: (Trunc64to32 (ZeroExt8to64 x))
@@ -23687,8 +23530,7 @@ func rewriteValuegeneric_OpTrunc64to8(v *Value) bool {
                }
                c := auxIntToInt64(v_0.AuxInt)
                v.reset(OpConst8)
-               var _auxint int8 = int8(c)
-               v.AuxInt = int8ToAuxInt(_auxint)
+               v.AuxInt = int8ToAuxInt(int8(c))
                return true
        }
        // match: (Trunc64to8 (ZeroExt8to64 x))
@@ -23755,8 +23597,7 @@ func rewriteValuegeneric_OpXor16(v *Value) bool {
                        }
                        d := auxIntToInt16(v_1.AuxInt)
                        v.reset(OpConst16)
-                       var _auxint int16 = c ^ d
-                       v.AuxInt = int16ToAuxInt(_auxint)
+                       v.AuxInt = int16ToAuxInt(c ^ d)
                        return true
                }
                break
@@ -23887,8 +23728,7 @@ func rewriteValuegeneric_OpXor32(v *Value) bool {
                        }
                        d := auxIntToInt32(v_1.AuxInt)
                        v.reset(OpConst32)
-                       var _auxint int32 = c ^ d
-                       v.AuxInt = int32ToAuxInt(_auxint)
+                       v.AuxInt = int32ToAuxInt(c ^ d)
                        return true
                }
                break
@@ -24019,8 +23859,7 @@ func rewriteValuegeneric_OpXor64(v *Value) bool {
                        }
                        d := auxIntToInt64(v_1.AuxInt)
                        v.reset(OpConst64)
-                       var _auxint int64 = c ^ d
-                       v.AuxInt = int64ToAuxInt(_auxint)
+                       v.AuxInt = int64ToAuxInt(c ^ d)
                        return true
                }
                break
@@ -24151,8 +23990,7 @@ func rewriteValuegeneric_OpXor8(v *Value) bool {
                        }
                        d := auxIntToInt8(v_1.AuxInt)
                        v.reset(OpConst8)
-                       var _auxint int8 = c ^ d
-                       v.AuxInt = int8ToAuxInt(_auxint)
+                       v.AuxInt = int8ToAuxInt(c ^ d)
                        return true
                }
                break
@@ -24383,8 +24221,7 @@ func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool {
                }
                c := auxIntToInt16(v_0.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = int32(uint16(c))
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(uint16(c)))
                return true
        }
        // match: (ZeroExt16to32 (Trunc32to16 x:(Rsh32Ux64 _ (Const64 [s]))))
@@ -24422,8 +24259,7 @@ func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool {
                }
                c := auxIntToInt16(v_0.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = int64(uint16(c))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(uint16(c)))
                return true
        }
        // match: (ZeroExt16to64 (Trunc64to16 x:(Rsh64Ux64 _ (Const64 [s]))))
@@ -24461,8 +24297,7 @@ func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool {
                }
                c := auxIntToInt32(v_0.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = int64(uint32(c))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(uint32(c)))
                return true
        }
        // match: (ZeroExt32to64 (Trunc64to32 x:(Rsh64Ux64 _ (Const64 [s]))))
@@ -24500,8 +24335,7 @@ func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool {
                }
                c := auxIntToInt8(v_0.AuxInt)
                v.reset(OpConst16)
-               var _auxint int16 = int16(uint8(c))
-               v.AuxInt = int16ToAuxInt(_auxint)
+               v.AuxInt = int16ToAuxInt(int16(uint8(c)))
                return true
        }
        // match: (ZeroExt8to16 (Trunc16to8 x:(Rsh16Ux64 _ (Const64 [s]))))
@@ -24539,8 +24373,7 @@ func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool {
                }
                c := auxIntToInt8(v_0.AuxInt)
                v.reset(OpConst32)
-               var _auxint int32 = int32(uint8(c))
-               v.AuxInt = int32ToAuxInt(_auxint)
+               v.AuxInt = int32ToAuxInt(int32(uint8(c)))
                return true
        }
        // match: (ZeroExt8to32 (Trunc32to8 x:(Rsh32Ux64 _ (Const64 [s]))))
@@ -24578,8 +24411,7 @@ func rewriteValuegeneric_OpZeroExt8to64(v *Value) bool {
                }
                c := auxIntToInt8(v_0.AuxInt)
                v.reset(OpConst64)
-               var _auxint int64 = int64(uint8(c))
-               v.AuxInt = int64ToAuxInt(_auxint)
+               v.AuxInt = int64ToAuxInt(int64(uint8(c)))
                return true
        }
        // match: (ZeroExt8to64 (Trunc64to8 x:(Rsh64Ux64 _ (Const64 [s]))))