cmd/compile: store the comparison pseudo-ops of arm64 conditional instructions in...

The current implementation stores the comparison pseudo-ops of arm64
conditional instructions (CSEL/CSEL0) in Aux, this patch modifies it
and stores it in AuxInt, which can avoid the allocation.

Change-Id: I0b69e51f63acd84c6878c6a59ccf6417501a8cfc
Reviewed-on: https://go-review.googlesource.com/c/go/+/252517
Run-TryBot: fannie zhang <Fannie.Zhang@arm.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index b6bb81a847c9d3b269a50dcdb1fc3857c9c69bf0..1d6ea6b9d8ed19e13de0b03e4e68640aaef6d4a8 100644 (file)
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -816,7 +816,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                }
                p := s.Prog(v.Op.Asm())
                p.From.Type = obj.TYPE_REG // assembler encodes conditional bits in Reg
-               p.From.Reg = condBits[v.Aux.(ssa.Op)]
+               p.From.Reg = condBits[ssa.Op(v.AuxInt)]
                p.Reg = v.Args[0].Reg()
                p.SetFrom3(obj.Addr{Type: obj.TYPE_REG, Reg: r1})
                p.To.Type = obj.TYPE_REG

diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go
index 98e1b79334809b7d1da00802f4d13181122d3bdc..828f645b399a7ed4a11979bb8f9f9b76c950184f 100644 (file)
--- a/src/cmd/compile/internal/ssa/check.go
+++ b/src/cmd/compile/internal/ssa/check.go
@@ -171,10 +171,10 @@ func checkFunc(f *Func) {
                                canHaveAuxInt = true
                                canHaveAux = true
                        case auxCCop:
-                               if _, ok := v.Aux.(Op); !ok {
-                                       f.Fatalf("bad type %T for CCop in %v", v.Aux, v)
+                               if opcodeTable[Op(v.AuxInt)].name == "OpInvalid" {
+                                       f.Fatalf("value %v has an AuxInt value that is a valid opcode", v)
                                }
-                               canHaveAux = true
+                               canHaveAuxInt = true
                        case auxS390XCCMask:
                                if _, ok := v.Aux.(s390x.CCMask); !ok {
                                        f.Fatalf("bad type %T for S390XCCMask in %v", v.Aux, v)

diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules
index c29e7f7edf896eb6f6b98150536a9d87a1db92ee..311067e87a39603adc3aa0c7289751e2f0b8b40c 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/ARM64.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules
@@ -132,65 +132,65 @@
 // we compare to 64 to ensure Go semantics for large shifts
 // Rules about rotates with non-const shift are based on the following rules,
 // if the following rules change, please also modify the rules based on them.
-(Lsh64x64 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
-(Lsh64x32 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
-(Lsh64x16 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
-(Lsh64x8  <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
-
-(Lsh32x64 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
-(Lsh32x32 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
-(Lsh32x16 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
-(Lsh32x8  <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
-
-(Lsh16x64 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
-(Lsh16x32 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
-(Lsh16x16 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
-(Lsh16x8  <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
-
-(Lsh8x64 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
-(Lsh8x32 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
-(Lsh8x16 <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
-(Lsh8x8  <t> x y) => (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
-
-(Rsh64Ux64 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
-(Rsh64Ux32 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
-(Rsh64Ux16 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
-(Rsh64Ux8  <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
-
-(Rsh32Ux64 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt32to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
-(Rsh32Ux32 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt32to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
-(Rsh32Ux16 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt32to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
-(Rsh32Ux8  <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt32to64 x) (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
-
-(Rsh16Ux64 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt16to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
-(Rsh16Ux32 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt16to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
-(Rsh16Ux16 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt16to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
-(Rsh16Ux8  <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt16to64 x) (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
-
-(Rsh8Ux64 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt8to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
-(Rsh8Ux32 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt8to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
-(Rsh8Ux16 <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt8to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
-(Rsh8Ux8  <t> x y) => (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt8to64 x) (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
-
-(Rsh64x64 x y) => (SRA x (CSEL {OpARM64LessThanU} <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
-(Rsh64x32 x y) => (SRA x (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
-(Rsh64x16 x y) => (SRA x (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
-(Rsh64x8  x y) => (SRA x (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt8to64  y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64  y))))
-
-(Rsh32x64 x y) => (SRA (SignExt32to64 x) (CSEL {OpARM64LessThanU} <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
-(Rsh32x32 x y) => (SRA (SignExt32to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
-(Rsh32x16 x y) => (SRA (SignExt32to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
-(Rsh32x8  x y) => (SRA (SignExt32to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt8to64  y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64  y))))
-
-(Rsh16x64 x y) => (SRA (SignExt16to64 x) (CSEL {OpARM64LessThanU} <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
-(Rsh16x32 x y) => (SRA (SignExt16to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
-(Rsh16x16 x y) => (SRA (SignExt16to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
-(Rsh16x8  x y) => (SRA (SignExt16to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt8to64  y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64  y))))
-
-(Rsh8x64 x y) => (SRA (SignExt8to64 x) (CSEL {OpARM64LessThanU} <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
-(Rsh8x32 x y) => (SRA (SignExt8to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
-(Rsh8x16 x y) => (SRA (SignExt8to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
-(Rsh8x8  x y) => (SRA (SignExt8to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt8to64  y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64  y))))
+(Lsh64x64 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+(Lsh64x32 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+(Lsh64x16 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+(Lsh64x8  <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
+
+(Lsh32x64 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+(Lsh32x32 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+(Lsh32x16 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+(Lsh32x8  <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
+
+(Lsh16x64 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+(Lsh16x32 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+(Lsh16x16 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+(Lsh16x8  <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
+
+(Lsh8x64 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+(Lsh8x32 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+(Lsh8x16 <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+(Lsh8x8  <t> x y) => (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
+
+(Rsh64Ux64 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+(Rsh64Ux32 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+(Rsh64Ux16 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+(Rsh64Ux8  <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> x (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
+
+(Rsh32Ux64 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt32to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
+(Rsh32Ux32 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt32to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+(Rsh32Ux16 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt32to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+(Rsh32Ux8  <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt32to64 x) (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
+
+(Rsh16Ux64 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt16to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
+(Rsh16Ux32 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt16to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+(Rsh16Ux16 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt16to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+(Rsh16Ux8  <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt16to64 x) (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
+
+(Rsh8Ux64 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt8to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
+(Rsh8Ux32 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt8to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+(Rsh8Ux16 <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt8to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+(Rsh8Ux8  <t> x y) => (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt8to64 x) (ZeroExt8to64  y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64  y)))
+
+(Rsh64x64 x y) => (SRA x (CSEL [OpARM64LessThanU] <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
+(Rsh64x32 x y) => (SRA x (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
+(Rsh64x16 x y) => (SRA x (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
+(Rsh64x8  x y) => (SRA x (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt8to64  y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64  y))))
+
+(Rsh32x64 x y) => (SRA (SignExt32to64 x) (CSEL [OpARM64LessThanU] <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
+(Rsh32x32 x y) => (SRA (SignExt32to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
+(Rsh32x16 x y) => (SRA (SignExt32to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
+(Rsh32x8  x y) => (SRA (SignExt32to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt8to64  y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64  y))))
+
+(Rsh16x64 x y) => (SRA (SignExt16to64 x) (CSEL [OpARM64LessThanU] <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
+(Rsh16x32 x y) => (SRA (SignExt16to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
+(Rsh16x16 x y) => (SRA (SignExt16to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
+(Rsh16x8  x y) => (SRA (SignExt16to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt8to64  y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64  y))))
+
+(Rsh8x64 x y) => (SRA (SignExt8to64 x) (CSEL [OpARM64LessThanU] <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
+(Rsh8x32 x y) => (SRA (SignExt8to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
+(Rsh8x16 x y) => (SRA (SignExt8to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
+(Rsh8x8  x y) => (SRA (SignExt8to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt8to64  y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64  y))))
 
 // constants
 (Const(64|32|16|8) [val]) => (MOVDconst [int64(val)])
@@ -315,8 +315,8 @@
 (FCMPD (FMOVDconst [0]) x) => (InvertFlags (FCMPD0 x))
 
 // CSEL needs a flag-generating argument. Synthesize a CMPW if necessary.
-(CondSelect x y boolval) && flagArg(boolval) != nil => (CSEL {boolval.Op} x y flagArg(boolval))
-(CondSelect x y boolval) && flagArg(boolval) == nil => (CSEL {OpARM64NotEqual} x y (CMPWconst [0] boolval))
+(CondSelect x y boolval) && flagArg(boolval) != nil => (CSEL [boolval.Op] x y flagArg(boolval))
+(CondSelect x y boolval) && flagArg(boolval) == nil => (CSEL [OpARM64NotEqual] x y (CMPWconst [0] boolval))
 
 (OffPtr [off] ptr:(SP)) && is32Bit(off) => (MOVDaddr [int32(off)] ptr)
 (OffPtr [off] ptr) => (ADDconst [off] ptr)
@@ -1324,8 +1324,8 @@
 (XOR x (MVN y)) -> (EON x y)
 (OR  x (MVN y)) -> (ORN x y)
 (MVN (XOR x y)) -> (EON x y)
-(CSEL {cc} x (MOVDconst [0]) flag) -> (CSEL0 {cc} x flag)
-(CSEL {cc} (MOVDconst [0]) y flag) -> (CSEL0 {arm64Negate(cc.(Op))} y flag)
+(CSEL [cc] x (MOVDconst [0]) flag) => (CSEL0 [cc] x flag)
+(CSEL [cc] (MOVDconst [0]) y flag) => (CSEL0 [arm64Negate(cc)] y flag)
 (SUB x (SUB y z)) -> (SUB (ADD <v.Type> x z) y)
 (SUB (SUB x y) z) -> (SUB x (ADD <y.Type> y z))
 
@@ -1481,8 +1481,8 @@
 (GTnoov (InvertFlags cmp) yes no) => (LTnoov cmp yes no)
 
 // absorb InvertFlags into CSEL(0)
-(CSEL {cc} x y (InvertFlags cmp)) => (CSEL {arm64Invert(cc)} x y cmp)
-(CSEL0 {cc} x (InvertFlags cmp)) => (CSEL0 {arm64Invert(cc)} x cmp)
+(CSEL [cc] x y (InvertFlags cmp)) => (CSEL [arm64Invert(cc)] x y cmp)
+(CSEL0 [cc] x (InvertFlags cmp)) => (CSEL0 [arm64Invert(cc)] x cmp)
 
 // absorb flag constants into boolean values
 (Equal (FlagConstant [fc])) => (MOVDconst [b2i(fc.eq())])
@@ -1517,20 +1517,20 @@
 (MOVBUreg x) && x.Type.IsBoolean() => (MOVDreg x)
 
 // absorb flag constants into conditional instructions
-(CSEL {cc} x _ flag) && ccARM64Eval(cc, flag) > 0 => x
-(CSEL {cc} _ y flag) && ccARM64Eval(cc, flag) < 0 => y
-(CSEL0 {cc} x flag) && ccARM64Eval(cc, flag) > 0 => x
-(CSEL0 {cc} _ flag) && ccARM64Eval(cc, flag) < 0 => (MOVDconst [0])
+(CSEL [cc] x _ flag) && ccARM64Eval(cc, flag) > 0 => x
+(CSEL [cc] _ y flag) && ccARM64Eval(cc, flag) < 0 => y
+(CSEL0 [cc] x flag) && ccARM64Eval(cc, flag) > 0 => x
+(CSEL0 [cc] _ flag) && ccARM64Eval(cc, flag) < 0 => (MOVDconst [0])
 
 // absorb flags back into boolean CSEL
-(CSEL {cc} x y (CMPWconst [0] boolval)) && cc == OpARM64NotEqual && flagArg(boolval) != nil =>
-      (CSEL {boolval.Op} x y flagArg(boolval))
-(CSEL {cc} x y (CMPWconst [0] boolval)) && cc == OpARM64Equal && flagArg(boolval) != nil =>
-      (CSEL {arm64Negate(boolval.Op)} x y flagArg(boolval))
-(CSEL0 {cc} x (CMPWconst [0] boolval)) && cc == OpARM64NotEqual && flagArg(boolval) != nil =>
-      (CSEL0 {boolval.Op} x flagArg(boolval))
-(CSEL0 {cc} x (CMPWconst [0] boolval)) && cc == OpARM64Equal && flagArg(boolval) != nil =>
-      (CSEL0 {arm64Negate(boolval.Op)} x flagArg(boolval))
+(CSEL [cc] x y (CMPWconst [0] boolval)) && cc == OpARM64NotEqual && flagArg(boolval) != nil =>
+      (CSEL [boolval.Op] x y flagArg(boolval))
+(CSEL [cc] x y (CMPWconst [0] boolval)) && cc == OpARM64Equal && flagArg(boolval) != nil =>
+      (CSEL [arm64Negate(boolval.Op)] x y flagArg(boolval))
+(CSEL0 [cc] x (CMPWconst [0] boolval)) && cc == OpARM64NotEqual && flagArg(boolval) != nil =>
+      (CSEL0 [boolval.Op] x flagArg(boolval))
+(CSEL0 [cc] x (CMPWconst [0] boolval)) && cc == OpARM64Equal && flagArg(boolval) != nil =>
+      (CSEL0 [arm64Negate(boolval.Op)] x flagArg(boolval))
 
 // absorb shifts into ops
 (NEG x:(SLLconst [c] y)) && clobberIfDead(x) => (NEGshiftLL [c] y)
@@ -1691,11 +1691,11 @@
 // "|" can also be "^" or "+".
 // As arm64 does not have a ROL instruction, so ROL(x, y) is replaced by ROR(x, -y).
 ((ADD|OR|XOR) (SLL x (ANDconst <t> [63] y))
-       (CSEL0 <typ.UInt64> {cc} (SRL <typ.UInt64> x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))
+       (CSEL0 <typ.UInt64> [cc] (SRL <typ.UInt64> x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))
                (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))))) && cc == OpARM64LessThanU
        => (ROR x (NEG <t> y))
 ((ADD|OR|XOR) (SRL <typ.UInt64> x (ANDconst <t> [63] y))
-       (CSEL0 <typ.UInt64> {cc} (SLL x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))
+       (CSEL0 <typ.UInt64> [cc] (SLL x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))
                (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))))) && cc == OpARM64LessThanU
        => (ROR x y)
 
@@ -1705,11 +1705,11 @@
 // "|" can also be "^" or "+".
 // As arm64 does not have a ROLW instruction, so ROLW(x, y) is replaced by RORW(x, -y).
 ((ADD|OR|XOR) (SLL x (ANDconst <t> [31] y))
-       (CSEL0 <typ.UInt32> {cc} (SRL <typ.UInt32> (MOVWUreg x) (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))
+       (CSEL0 <typ.UInt32> [cc] (SRL <typ.UInt32> (MOVWUreg x) (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))
                (CMPconst [64]  (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))))) && cc == OpARM64LessThanU
        => (RORW x (NEG <t> y))
 ((ADD|OR|XOR) (SRL <typ.UInt32> (MOVWUreg x) (ANDconst <t> [31] y))
-       (CSEL0 <typ.UInt32> {cc} (SLL x (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))
+       (CSEL0 <typ.UInt32> [cc] (SLL x (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))
                (CMPconst [64]  (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))))) && cc == OpARM64LessThanU
        => (RORW x y)
 

diff --git a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
index 2424e67e201dabefedf1bdc1bac63fe4b2dcc94f..e9af261a6ae41ba72554833a238c67aaad91ac12 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go
@@ -467,8 +467,8 @@ func init() {
 
                // conditional instructions; auxint is
                // one of the arm64 comparison pseudo-ops (LessThan, LessThanU, etc.)
-               {name: "CSEL", argLength: 3, reg: gp2flags1, asm: "CSEL", aux: "CCop"},  // aux(flags) ? arg0 : arg1
-               {name: "CSEL0", argLength: 2, reg: gp1flags1, asm: "CSEL", aux: "CCop"}, // aux(flags) ? arg0 : 0
+               {name: "CSEL", argLength: 3, reg: gp2flags1, asm: "CSEL", aux: "CCop"},  // auxint(flags) ? arg0 : arg1
+               {name: "CSEL0", argLength: 2, reg: gp1flags1, asm: "CSEL", aux: "CCop"}, // auxint(flags) ? arg0 : 0
 
                // function calls
                {name: "CALLstatic", argLength: 1, reg: regInfo{clobbers: callerSave}, aux: "SymOff", clobberFlags: true, call: true, symEffect: "None"},                           // call static function aux.(*obj.LSym).  arg0=mem, auxint=argsize, returns mem

diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index e520503ab123a642e5e146fd4801639e9cae88b1..9e2e112cd79ed0aa72b874cd6477570d6cf3cda3 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -1423,7 +1423,8 @@ func parseValue(val string, arch arch, loc string) (op opData, oparch, typ, auxi
 
 func opHasAuxInt(op opData) bool {
        switch op.aux {
-       case "Bool", "Int8", "Int16", "Int32", "Int64", "Int128", "Float32", "Float64", "SymOff", "SymValAndOff", "TypSize", "ARM64BitField", "FlagConstant":
+       case "Bool", "Int8", "Int16", "Int32", "Int64", "Int128", "Float32", "Float64",
+               "SymOff", "SymValAndOff", "TypSize", "ARM64BitField", "FlagConstant", "CCop":
                return true
        }
        return false
@@ -1431,7 +1432,7 @@ func opHasAuxInt(op opData) bool {
 
 func opHasAux(op opData) bool {
        switch op.aux {
-       case "String", "Sym", "SymOff", "SymValAndOff", "Typ", "TypSize", "CCop",
+       case "String", "Sym", "SymOff", "SymValAndOff", "Typ", "TypSize",
                "S390XCCMask", "S390XRotateParams":
                return true
        }
@@ -1784,8 +1785,6 @@ func (op opData) auxType() string {
                return "s390x.CCMask"
        case "S390XRotateParams":
                return "s390x.RotateParams"
-       case "CCop":
-               return "CCop"
        default:
                return "invalid"
        }

diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 3df9ad24f91a3c0c3a163290a5f69bf75237c936..09f94ef53e6629d867a5a4c8a3e47cfd7757adcf 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -651,6 +651,10 @@ func auxIntToFlagConstant(x int64) flagConstant {
        return flagConstant(x)
 }
 
+func auxIntToOp(cc int64) Op {
+       return Op(cc)
+}
+
 func boolToAuxInt(b bool) int64 {
        if b {
                return 1
@@ -694,6 +698,10 @@ func flagConstantToAuxInt(x flagConstant) int64 {
        return int64(x)
 }
 
+func opToAuxInt(o Op) int64 {
+       return int64(o)
+}
+
 func auxToString(i interface{}) string {
        return i.(string)
 }
@@ -727,13 +735,6 @@ func s390xCCMaskToAux(c s390x.CCMask) interface{} {
 func s390xRotateParamsToAux(r s390x.RotateParams) interface{} {
        return r
 }
-func cCopToAux(o Op) interface{} {
-       return o
-}
-
-func auxToCCop(cc interface{}) Op {
-       return cc.(Op)
-}
 
 // uaddOvf reports whether unsigned a+b would overflow.
 func uaddOvf(a, b int64) bool {

diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index 453578aa9aa32c6cb950ba9b9b5bfb8c85d45e1d..0fb86b6bdd65994a9c66f62eac47d206cb146fb0 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -1285,7 +1285,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value) bool {
                }
                break
        }
-       // match: (ADD (SLL x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> {cc} (SRL <typ.UInt64> x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
+       // match: (ADD (SLL x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> [cc] (SRL <typ.UInt64> x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (ROR x (NEG <t> y))
        for {
@@ -1307,7 +1307,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt64 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SRL || v_1_0.Type != typ.UInt64 {
@@ -1355,7 +1355,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value) bool {
                }
                break
        }
-       // match: (ADD (SRL <typ.UInt64> x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> {cc} (SLL x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
+       // match: (ADD (SRL <typ.UInt64> x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> [cc] (SLL x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (ROR x y)
        for {
@@ -1377,7 +1377,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt64 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SLL {
@@ -1423,7 +1423,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value) bool {
                }
                break
        }
-       // match: (ADD (SLL x (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> {cc} (SRL <typ.UInt32> (MOVWUreg x) (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
+       // match: (ADD (SLL x (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> [cc] (SRL <typ.UInt32> (MOVWUreg x) (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (RORW x (NEG <t> y))
        for {
@@ -1445,7 +1445,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt32 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SRL || v_1_0.Type != typ.UInt32 {
@@ -1494,7 +1494,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value) bool {
                }
                break
        }
-       // match: (ADD (SRL <typ.UInt32> (MOVWUreg x) (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> {cc} (SLL x (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
+       // match: (ADD (SRL <typ.UInt32> (MOVWUreg x) (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> [cc] (SLL x (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (RORW x y)
        for {
@@ -1520,7 +1520,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt32 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SLL {
@@ -3178,38 +3178,38 @@ func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
        v_2 := v.Args[2]
        v_1 := v.Args[1]
        v_0 := v.Args[0]
-       // match: (CSEL {cc} x (MOVDconst [0]) flag)
-       // result: (CSEL0 {cc} x flag)
+       // match: (CSEL [cc] x (MOVDconst [0]) flag)
+       // result: (CSEL0 [cc] x flag)
        for {
-               cc := v.Aux
+               cc := auxIntToOp(v.AuxInt)
                x := v_0
-               if v_1.Op != OpARM64MOVDconst || v_1.AuxInt != 0 {
+               if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
                        break
                }
                flag := v_2
                v.reset(OpARM64CSEL0)
-               v.Aux = cc
+               v.AuxInt = opToAuxInt(cc)
                v.AddArg2(x, flag)
                return true
        }
-       // match: (CSEL {cc} (MOVDconst [0]) y flag)
-       // result: (CSEL0 {arm64Negate(cc.(Op))} y flag)
+       // match: (CSEL [cc] (MOVDconst [0]) y flag)
+       // result: (CSEL0 [arm64Negate(cc)] y flag)
        for {
-               cc := v.Aux
-               if v_0.Op != OpARM64MOVDconst || v_0.AuxInt != 0 {
+               cc := auxIntToOp(v.AuxInt)
+               if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
                        break
                }
                y := v_1
                flag := v_2
                v.reset(OpARM64CSEL0)
-               v.Aux = arm64Negate(cc.(Op))
+               v.AuxInt = opToAuxInt(arm64Negate(cc))
                v.AddArg2(y, flag)
                return true
        }
-       // match: (CSEL {cc} x y (InvertFlags cmp))
-       // result: (CSEL {arm64Invert(cc)} x y cmp)
+       // match: (CSEL [cc] x y (InvertFlags cmp))
+       // result: (CSEL [arm64Invert(cc)] x y cmp)
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                x := v_0
                y := v_1
                if v_2.Op != OpARM64InvertFlags {
@@ -3217,15 +3217,15 @@ func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
                }
                cmp := v_2.Args[0]
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(arm64Invert(cc))
+               v.AuxInt = opToAuxInt(arm64Invert(cc))
                v.AddArg3(x, y, cmp)
                return true
        }
-       // match: (CSEL {cc} x _ flag)
+       // match: (CSEL [cc] x _ flag)
        // cond: ccARM64Eval(cc, flag) > 0
        // result: x
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                x := v_0
                flag := v_2
                if !(ccARM64Eval(cc, flag) > 0) {
@@ -3234,11 +3234,11 @@ func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
                v.copyOf(x)
                return true
        }
-       // match: (CSEL {cc} _ y flag)
+       // match: (CSEL [cc] _ y flag)
        // cond: ccARM64Eval(cc, flag) < 0
        // result: y
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                y := v_1
                flag := v_2
                if !(ccARM64Eval(cc, flag) < 0) {
@@ -3247,11 +3247,11 @@ func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
                v.copyOf(y)
                return true
        }
-       // match: (CSEL {cc} x y (CMPWconst [0] boolval))
+       // match: (CSEL [cc] x y (CMPWconst [0] boolval))
        // cond: cc == OpARM64NotEqual && flagArg(boolval) != nil
-       // result: (CSEL {boolval.Op} x y flagArg(boolval))
+       // result: (CSEL [boolval.Op] x y flagArg(boolval))
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                x := v_0
                y := v_1
                if v_2.Op != OpARM64CMPWconst || auxIntToInt32(v_2.AuxInt) != 0 {
@@ -3262,15 +3262,15 @@ func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
                        break
                }
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(boolval.Op)
+               v.AuxInt = opToAuxInt(boolval.Op)
                v.AddArg3(x, y, flagArg(boolval))
                return true
        }
-       // match: (CSEL {cc} x y (CMPWconst [0] boolval))
+       // match: (CSEL [cc] x y (CMPWconst [0] boolval))
        // cond: cc == OpARM64Equal && flagArg(boolval) != nil
-       // result: (CSEL {arm64Negate(boolval.Op)} x y flagArg(boolval))
+       // result: (CSEL [arm64Negate(boolval.Op)] x y flagArg(boolval))
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                x := v_0
                y := v_1
                if v_2.Op != OpARM64CMPWconst || auxIntToInt32(v_2.AuxInt) != 0 {
@@ -3281,7 +3281,7 @@ func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
                        break
                }
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(arm64Negate(boolval.Op))
+               v.AuxInt = opToAuxInt(arm64Negate(boolval.Op))
                v.AddArg3(x, y, flagArg(boolval))
                return true
        }
@@ -3290,25 +3290,25 @@ func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
 func rewriteValueARM64_OpARM64CSEL0(v *Value) bool {
        v_1 := v.Args[1]
        v_0 := v.Args[0]
-       // match: (CSEL0 {cc} x (InvertFlags cmp))
-       // result: (CSEL0 {arm64Invert(cc)} x cmp)
+       // match: (CSEL0 [cc] x (InvertFlags cmp))
+       // result: (CSEL0 [arm64Invert(cc)] x cmp)
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                x := v_0
                if v_1.Op != OpARM64InvertFlags {
                        break
                }
                cmp := v_1.Args[0]
                v.reset(OpARM64CSEL0)
-               v.Aux = cCopToAux(arm64Invert(cc))
+               v.AuxInt = opToAuxInt(arm64Invert(cc))
                v.AddArg2(x, cmp)
                return true
        }
-       // match: (CSEL0 {cc} x flag)
+       // match: (CSEL0 [cc] x flag)
        // cond: ccARM64Eval(cc, flag) > 0
        // result: x
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                x := v_0
                flag := v_1
                if !(ccARM64Eval(cc, flag) > 0) {
@@ -3317,11 +3317,11 @@ func rewriteValueARM64_OpARM64CSEL0(v *Value) bool {
                v.copyOf(x)
                return true
        }
-       // match: (CSEL0 {cc} _ flag)
+       // match: (CSEL0 [cc] _ flag)
        // cond: ccARM64Eval(cc, flag) < 0
        // result: (MOVDconst [0])
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                flag := v_1
                if !(ccARM64Eval(cc, flag) < 0) {
                        break
@@ -3330,11 +3330,11 @@ func rewriteValueARM64_OpARM64CSEL0(v *Value) bool {
                v.AuxInt = int64ToAuxInt(0)
                return true
        }
-       // match: (CSEL0 {cc} x (CMPWconst [0] boolval))
+       // match: (CSEL0 [cc] x (CMPWconst [0] boolval))
        // cond: cc == OpARM64NotEqual && flagArg(boolval) != nil
-       // result: (CSEL0 {boolval.Op} x flagArg(boolval))
+       // result: (CSEL0 [boolval.Op] x flagArg(boolval))
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                x := v_0
                if v_1.Op != OpARM64CMPWconst || auxIntToInt32(v_1.AuxInt) != 0 {
                        break
@@ -3344,15 +3344,15 @@ func rewriteValueARM64_OpARM64CSEL0(v *Value) bool {
                        break
                }
                v.reset(OpARM64CSEL0)
-               v.Aux = cCopToAux(boolval.Op)
+               v.AuxInt = opToAuxInt(boolval.Op)
                v.AddArg2(x, flagArg(boolval))
                return true
        }
-       // match: (CSEL0 {cc} x (CMPWconst [0] boolval))
+       // match: (CSEL0 [cc] x (CMPWconst [0] boolval))
        // cond: cc == OpARM64Equal && flagArg(boolval) != nil
-       // result: (CSEL0 {arm64Negate(boolval.Op)} x flagArg(boolval))
+       // result: (CSEL0 [arm64Negate(boolval.Op)] x flagArg(boolval))
        for {
-               cc := auxToCCop(v.Aux)
+               cc := auxIntToOp(v.AuxInt)
                x := v_0
                if v_1.Op != OpARM64CMPWconst || auxIntToInt32(v_1.AuxInt) != 0 {
                        break
@@ -3362,7 +3362,7 @@ func rewriteValueARM64_OpARM64CSEL0(v *Value) bool {
                        break
                }
                v.reset(OpARM64CSEL0)
-               v.Aux = cCopToAux(arm64Negate(boolval.Op))
+               v.AuxInt = opToAuxInt(arm64Negate(boolval.Op))
                v.AddArg2(x, flagArg(boolval))
                return true
        }
@@ -15043,7 +15043,7 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool {
                }
                break
        }
-       // match: (OR (SLL x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> {cc} (SRL <typ.UInt64> x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
+       // match: (OR (SLL x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> [cc] (SRL <typ.UInt64> x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (ROR x (NEG <t> y))
        for {
@@ -15065,7 +15065,7 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt64 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SRL || v_1_0.Type != typ.UInt64 {
@@ -15113,7 +15113,7 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool {
                }
                break
        }
-       // match: (OR (SRL <typ.UInt64> x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> {cc} (SLL x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
+       // match: (OR (SRL <typ.UInt64> x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> [cc] (SLL x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (ROR x y)
        for {
@@ -15135,7 +15135,7 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt64 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SLL {
@@ -15181,7 +15181,7 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool {
                }
                break
        }
-       // match: (OR (SLL x (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> {cc} (SRL <typ.UInt32> (MOVWUreg x) (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
+       // match: (OR (SLL x (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> [cc] (SRL <typ.UInt32> (MOVWUreg x) (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (RORW x (NEG <t> y))
        for {
@@ -15203,7 +15203,7 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt32 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SRL || v_1_0.Type != typ.UInt32 {
@@ -15252,7 +15252,7 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool {
                }
                break
        }
-       // match: (OR (SRL <typ.UInt32> (MOVWUreg x) (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> {cc} (SLL x (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
+       // match: (OR (SRL <typ.UInt32> (MOVWUreg x) (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> [cc] (SLL x (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (RORW x y)
        for {
@@ -15278,7 +15278,7 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt32 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SLL {
@@ -20713,7 +20713,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value) bool {
                }
                break
        }
-       // match: (XOR (SLL x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> {cc} (SRL <typ.UInt64> x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
+       // match: (XOR (SLL x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> [cc] (SRL <typ.UInt64> x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (ROR x (NEG <t> y))
        for {
@@ -20735,7 +20735,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt64 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SRL || v_1_0.Type != typ.UInt64 {
@@ -20783,7 +20783,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value) bool {
                }
                break
        }
-       // match: (XOR (SRL <typ.UInt64> x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> {cc} (SLL x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
+       // match: (XOR (SRL <typ.UInt64> x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> [cc] (SLL x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (ROR x y)
        for {
@@ -20805,7 +20805,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt64 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SLL {
@@ -20851,7 +20851,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value) bool {
                }
                break
        }
-       // match: (XOR (SLL x (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> {cc} (SRL <typ.UInt32> (MOVWUreg x) (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
+       // match: (XOR (SLL x (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> [cc] (SRL <typ.UInt32> (MOVWUreg x) (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (RORW x (NEG <t> y))
        for {
@@ -20873,7 +20873,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt32 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SRL || v_1_0.Type != typ.UInt32 {
@@ -20922,7 +20922,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value) bool {
                }
                break
        }
-       // match: (XOR (SRL <typ.UInt32> (MOVWUreg x) (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> {cc} (SLL x (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
+       // match: (XOR (SRL <typ.UInt32> (MOVWUreg x) (ANDconst <t> [31] y)) (CSEL0 <typ.UInt32> [cc] (SLL x (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y))) (CMPconst [64] (SUB <t> (MOVDconst [32]) (ANDconst <t> [31] y)))))
        // cond: cc == OpARM64LessThanU
        // result: (RORW x y)
        for {
@@ -20948,7 +20948,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value) bool {
                        if v_1.Op != OpARM64CSEL0 || v_1.Type != typ.UInt32 {
                                continue
                        }
-                       cc := auxToCCop(v_1.Aux)
+                       cc := auxIntToOp(v_1.AuxInt)
                        _ = v_1.Args[1]
                        v_1_0 := v_1.Args[0]
                        if v_1_0.Op != OpARM64SLL {
@@ -21471,7 +21471,7 @@ func rewriteValueARM64_OpCondSelect(v *Value) bool {
        b := v.Block
        // match: (CondSelect x y boolval)
        // cond: flagArg(boolval) != nil
-       // result: (CSEL {boolval.Op} x y flagArg(boolval))
+       // result: (CSEL [boolval.Op] x y flagArg(boolval))
        for {
                x := v_0
                y := v_1
@@ -21480,13 +21480,13 @@ func rewriteValueARM64_OpCondSelect(v *Value) bool {
                        break
                }
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(boolval.Op)
+               v.AuxInt = opToAuxInt(boolval.Op)
                v.AddArg3(x, y, flagArg(boolval))
                return true
        }
        // match: (CondSelect x y boolval)
        // cond: flagArg(boolval) == nil
-       // result: (CSEL {OpARM64NotEqual} x y (CMPWconst [0] boolval))
+       // result: (CSEL [OpARM64NotEqual] x y (CMPWconst [0] boolval))
        for {
                x := v_0
                y := v_1
@@ -21495,7 +21495,7 @@ func rewriteValueARM64_OpCondSelect(v *Value) bool {
                        break
                }
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64NotEqual)
+               v.AuxInt = opToAuxInt(OpARM64NotEqual)
                v0 := b.NewValue0(v.Pos, OpARM64CMPWconst, types.TypeFlags)
                v0.AuxInt = int32ToAuxInt(0)
                v0.AddArg(boolval)
@@ -22734,13 +22734,13 @@ func rewriteValueARM64_OpLsh16x16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh16x16 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(y)
@@ -22760,13 +22760,13 @@ func rewriteValueARM64_OpLsh16x32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh16x32 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(y)
@@ -22785,13 +22785,13 @@ func rewriteValueARM64_OpLsh16x64(v *Value) bool {
        v_0 := v.Args[0]
        b := v.Block
        // match: (Lsh16x64 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v0.AddArg2(x, y)
                v1 := b.NewValue0(v.Pos, OpConst64, t)
@@ -22809,13 +22809,13 @@ func rewriteValueARM64_OpLsh16x8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh16x8 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(y)
@@ -22835,13 +22835,13 @@ func rewriteValueARM64_OpLsh32x16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh32x16 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(y)
@@ -22861,13 +22861,13 @@ func rewriteValueARM64_OpLsh32x32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh32x32 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(y)
@@ -22886,13 +22886,13 @@ func rewriteValueARM64_OpLsh32x64(v *Value) bool {
        v_0 := v.Args[0]
        b := v.Block
        // match: (Lsh32x64 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v0.AddArg2(x, y)
                v1 := b.NewValue0(v.Pos, OpConst64, t)
@@ -22910,13 +22910,13 @@ func rewriteValueARM64_OpLsh32x8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh32x8 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(y)
@@ -22936,13 +22936,13 @@ func rewriteValueARM64_OpLsh64x16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh64x16 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(y)
@@ -22962,13 +22962,13 @@ func rewriteValueARM64_OpLsh64x32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh64x32 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(y)
@@ -22987,13 +22987,13 @@ func rewriteValueARM64_OpLsh64x64(v *Value) bool {
        v_0 := v.Args[0]
        b := v.Block
        // match: (Lsh64x64 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v0.AddArg2(x, y)
                v1 := b.NewValue0(v.Pos, OpConst64, t)
@@ -23011,13 +23011,13 @@ func rewriteValueARM64_OpLsh64x8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh64x8 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(y)
@@ -23037,13 +23037,13 @@ func rewriteValueARM64_OpLsh8x16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh8x16 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(y)
@@ -23063,13 +23063,13 @@ func rewriteValueARM64_OpLsh8x32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh8x32 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(y)
@@ -23088,13 +23088,13 @@ func rewriteValueARM64_OpLsh8x64(v *Value) bool {
        v_0 := v.Args[0]
        b := v.Block
        // match: (Lsh8x64 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v0.AddArg2(x, y)
                v1 := b.NewValue0(v.Pos, OpConst64, t)
@@ -23112,13 +23112,13 @@ func rewriteValueARM64_OpLsh8x8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Lsh8x8 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(y)
@@ -23932,13 +23932,13 @@ func rewriteValueARM64_OpRsh16Ux16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh16Ux16 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt16to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt16to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(x)
@@ -23960,13 +23960,13 @@ func rewriteValueARM64_OpRsh16Ux32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh16Ux32 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt16to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt16to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(x)
@@ -23988,13 +23988,13 @@ func rewriteValueARM64_OpRsh16Ux64(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh16Ux64 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt16to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt16to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(x)
@@ -24014,13 +24014,13 @@ func rewriteValueARM64_OpRsh16Ux8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh16Ux8 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt16to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt16to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(x)
@@ -24042,7 +24042,7 @@ func rewriteValueARM64_OpRsh16x16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh16x16 x y)
-       // result: (SRA (SignExt16to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
+       // result: (SRA (SignExt16to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
        for {
                x := v_0
                y := v_1
@@ -24050,7 +24050,7 @@ func rewriteValueARM64_OpRsh16x16(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v2.AddArg(y)
                v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24069,7 +24069,7 @@ func rewriteValueARM64_OpRsh16x32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh16x32 x y)
-       // result: (SRA (SignExt16to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
+       // result: (SRA (SignExt16to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
        for {
                x := v_0
                y := v_1
@@ -24077,7 +24077,7 @@ func rewriteValueARM64_OpRsh16x32(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v2.AddArg(y)
                v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24096,7 +24096,7 @@ func rewriteValueARM64_OpRsh16x64(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh16x64 x y)
-       // result: (SRA (SignExt16to64 x) (CSEL {OpARM64LessThanU} <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
+       // result: (SRA (SignExt16to64 x) (CSEL [OpARM64LessThanU] <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
        for {
                x := v_0
                y := v_1
@@ -24104,7 +24104,7 @@ func rewriteValueARM64_OpRsh16x64(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpConst64, y.Type)
                v2.AuxInt = int64ToAuxInt(63)
                v3 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
@@ -24121,7 +24121,7 @@ func rewriteValueARM64_OpRsh16x8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh16x8 x y)
-       // result: (SRA (SignExt16to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
+       // result: (SRA (SignExt16to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
        for {
                x := v_0
                y := v_1
@@ -24129,7 +24129,7 @@ func rewriteValueARM64_OpRsh16x8(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v2.AddArg(y)
                v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24148,13 +24148,13 @@ func rewriteValueARM64_OpRsh32Ux16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh32Ux16 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt32to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt32to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(x)
@@ -24176,13 +24176,13 @@ func rewriteValueARM64_OpRsh32Ux32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh32Ux32 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt32to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt32to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(x)
@@ -24204,13 +24204,13 @@ func rewriteValueARM64_OpRsh32Ux64(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh32Ux64 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt32to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt32to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(x)
@@ -24230,13 +24230,13 @@ func rewriteValueARM64_OpRsh32Ux8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh32Ux8 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt32to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt32to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(x)
@@ -24258,7 +24258,7 @@ func rewriteValueARM64_OpRsh32x16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh32x16 x y)
-       // result: (SRA (SignExt32to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
+       // result: (SRA (SignExt32to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
        for {
                x := v_0
                y := v_1
@@ -24266,7 +24266,7 @@ func rewriteValueARM64_OpRsh32x16(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v2.AddArg(y)
                v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24285,7 +24285,7 @@ func rewriteValueARM64_OpRsh32x32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh32x32 x y)
-       // result: (SRA (SignExt32to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
+       // result: (SRA (SignExt32to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
        for {
                x := v_0
                y := v_1
@@ -24293,7 +24293,7 @@ func rewriteValueARM64_OpRsh32x32(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v2.AddArg(y)
                v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24312,7 +24312,7 @@ func rewriteValueARM64_OpRsh32x64(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh32x64 x y)
-       // result: (SRA (SignExt32to64 x) (CSEL {OpARM64LessThanU} <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
+       // result: (SRA (SignExt32to64 x) (CSEL [OpARM64LessThanU] <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
        for {
                x := v_0
                y := v_1
@@ -24320,7 +24320,7 @@ func rewriteValueARM64_OpRsh32x64(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpConst64, y.Type)
                v2.AuxInt = int64ToAuxInt(63)
                v3 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
@@ -24337,7 +24337,7 @@ func rewriteValueARM64_OpRsh32x8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh32x8 x y)
-       // result: (SRA (SignExt32to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
+       // result: (SRA (SignExt32to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
        for {
                x := v_0
                y := v_1
@@ -24345,7 +24345,7 @@ func rewriteValueARM64_OpRsh32x8(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v2.AddArg(y)
                v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24364,13 +24364,13 @@ func rewriteValueARM64_OpRsh64Ux16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh64Ux16 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(y)
@@ -24390,13 +24390,13 @@ func rewriteValueARM64_OpRsh64Ux32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh64Ux32 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(y)
@@ -24415,13 +24415,13 @@ func rewriteValueARM64_OpRsh64Ux64(v *Value) bool {
        v_0 := v.Args[0]
        b := v.Block
        // match: (Rsh64Ux64 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> x y) (Const64 <t> [0]) (CMPconst [64] y))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v0.AddArg2(x, y)
                v1 := b.NewValue0(v.Pos, OpConst64, t)
@@ -24439,13 +24439,13 @@ func rewriteValueARM64_OpRsh64Ux8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh64Ux8 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(y)
@@ -24465,13 +24465,13 @@ func rewriteValueARM64_OpRsh64x16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh64x16 x y)
-       // result: (SRA x (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
+       // result: (SRA x (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
        for {
                x := v_0
                y := v_1
                v.reset(OpARM64SRA)
                v0 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v0.Aux = cCopToAux(OpARM64LessThanU)
+               v0.AuxInt = opToAuxInt(OpARM64LessThanU)
                v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v1.AddArg(y)
                v2 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24490,13 +24490,13 @@ func rewriteValueARM64_OpRsh64x32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh64x32 x y)
-       // result: (SRA x (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
+       // result: (SRA x (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
        for {
                x := v_0
                y := v_1
                v.reset(OpARM64SRA)
                v0 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v0.Aux = cCopToAux(OpARM64LessThanU)
+               v0.AuxInt = opToAuxInt(OpARM64LessThanU)
                v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v1.AddArg(y)
                v2 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24514,13 +24514,13 @@ func rewriteValueARM64_OpRsh64x64(v *Value) bool {
        v_0 := v.Args[0]
        b := v.Block
        // match: (Rsh64x64 x y)
-       // result: (SRA x (CSEL {OpARM64LessThanU} <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
+       // result: (SRA x (CSEL [OpARM64LessThanU] <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
        for {
                x := v_0
                y := v_1
                v.reset(OpARM64SRA)
                v0 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v0.Aux = cCopToAux(OpARM64LessThanU)
+               v0.AuxInt = opToAuxInt(OpARM64LessThanU)
                v1 := b.NewValue0(v.Pos, OpConst64, y.Type)
                v1.AuxInt = int64ToAuxInt(63)
                v2 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
@@ -24537,13 +24537,13 @@ func rewriteValueARM64_OpRsh64x8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh64x8 x y)
-       // result: (SRA x (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
+       // result: (SRA x (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
        for {
                x := v_0
                y := v_1
                v.reset(OpARM64SRA)
                v0 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v0.Aux = cCopToAux(OpARM64LessThanU)
+               v0.AuxInt = opToAuxInt(OpARM64LessThanU)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(y)
                v2 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24562,13 +24562,13 @@ func rewriteValueARM64_OpRsh8Ux16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh8Ux16 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt8to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt8to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(x)
@@ -24590,13 +24590,13 @@ func rewriteValueARM64_OpRsh8Ux32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh8Ux32 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt8to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt8to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(x)
@@ -24618,13 +24618,13 @@ func rewriteValueARM64_OpRsh8Ux64(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh8Ux64 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt8to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt8to64 x) y) (Const64 <t> [0]) (CMPconst [64] y))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(x)
@@ -24644,13 +24644,13 @@ func rewriteValueARM64_OpRsh8Ux8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh8Ux8 <t> x y)
-       // result: (CSEL {OpARM64LessThanU} (SRL <t> (ZeroExt8to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
+       // result: (CSEL [OpARM64LessThanU] (SRL <t> (ZeroExt8to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
        for {
                t := v.Type
                x := v_0
                y := v_1
                v.reset(OpARM64CSEL)
-               v.Aux = cCopToAux(OpARM64LessThanU)
+               v.AuxInt = opToAuxInt(OpARM64LessThanU)
                v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
                v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v1.AddArg(x)
@@ -24672,7 +24672,7 @@ func rewriteValueARM64_OpRsh8x16(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh8x16 x y)
-       // result: (SRA (SignExt8to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
+       // result: (SRA (SignExt8to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
        for {
                x := v_0
                y := v_1
@@ -24680,7 +24680,7 @@ func rewriteValueARM64_OpRsh8x16(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
                v2.AddArg(y)
                v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24699,7 +24699,7 @@ func rewriteValueARM64_OpRsh8x32(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh8x32 x y)
-       // result: (SRA (SignExt8to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
+       // result: (SRA (SignExt8to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
        for {
                x := v_0
                y := v_1
@@ -24707,7 +24707,7 @@ func rewriteValueARM64_OpRsh8x32(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
                v2.AddArg(y)
                v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
@@ -24726,7 +24726,7 @@ func rewriteValueARM64_OpRsh8x64(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh8x64 x y)
-       // result: (SRA (SignExt8to64 x) (CSEL {OpARM64LessThanU} <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
+       // result: (SRA (SignExt8to64 x) (CSEL [OpARM64LessThanU] <y.Type> y (Const64 <y.Type> [63]) (CMPconst [64] y)))
        for {
                x := v_0
                y := v_1
@@ -24734,7 +24734,7 @@ func rewriteValueARM64_OpRsh8x64(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpConst64, y.Type)
                v2.AuxInt = int64ToAuxInt(63)
                v3 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
@@ -24751,7 +24751,7 @@ func rewriteValueARM64_OpRsh8x8(v *Value) bool {
        b := v.Block
        typ := &b.Func.Config.Types
        // match: (Rsh8x8 x y)
-       // result: (SRA (SignExt8to64 x) (CSEL {OpARM64LessThanU} <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
+       // result: (SRA (SignExt8to64 x) (CSEL [OpARM64LessThanU] <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
        for {
                x := v_0
                y := v_1
@@ -24759,7 +24759,7 @@ func rewriteValueARM64_OpRsh8x8(v *Value) bool {
                v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
                v0.AddArg(x)
                v1 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
-               v1.Aux = cCopToAux(OpARM64LessThanU)
+               v1.AuxInt = opToAuxInt(OpARM64LessThanU)
                v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
                v2.AddArg(y)
                v3 := b.NewValue0(v.Pos, OpConst64, y.Type)

diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go
index 7fc33772d3a6e1150ba9715899fdd22667e76cca..090745def7bf9fbec1740fc3b8bf6d68a515d77f 100644 (file)
--- a/src/cmd/compile/internal/ssa/value.go
+++ b/src/cmd/compile/internal/ssa/value.go
@@ -210,7 +210,7 @@ func (v *Value) auxString() string {
                }
                return s + fmt.Sprintf(" [%s]", v.AuxValAndOff())
        case auxCCop:
-               return fmt.Sprintf(" {%s}", v.Aux.(Op))
+               return fmt.Sprintf(" {%s}", Op(v.AuxInt))
        case auxS390XCCMask, auxS390XRotateParams:
                return fmt.Sprintf(" {%v}", v.Aux)
        case auxFlagConstant: