// It in not safe in general to move a variable between blocks
// (and particularly not a phi node).
// Introduce a copy.
- rr.add(stmtf("v.reset(OpCopy)"))
- rr.add(stmtf("v.Type = %s.Type", result))
- rr.add(stmtf("v.AddArg(%s)", result))
+ rr.add(stmtf("v.copyOf(%s)", result))
}
return result
}
rr.add(declf(v, "b.NewValue0(%s, Op%s%s, %s)", pos, oparch, op.name, typ))
if move && top {
// Rewrite original into a copy
- rr.add(stmtf("v.reset(OpCopy)"))
- rr.add(stmtf("v.AddArg(%s)", v))
+ rr.add(stmtf("v.copyOf(%s)", v))
}
}
return i
}
-// notStmtBoundary indicates which value opcodes can never be a statement
-// boundary because they don't correspond to a user's understanding of a
-// statement boundary. Called from *Value.reset(), and *Func.newValue(),
-// located here to keep all the statement boundary heuristics in one place.
-// Note: *Value.reset() filters out OpCopy because of how that is used in
-// rewrite.
+// notStmtBoundary reports whether a value with opcode op can never be a statement
+// boundary. Such values don't correspond to a user's understanding of a
+// statement boundary.
func notStmtBoundary(op Op) bool {
switch op {
case OpCopy, OpPhi, OpVarKill, OpVarDef, OpVarLive, OpUnknown, OpFwdRef, OpArg:
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDLconst [c] (MOVLconst [d]))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(int32(c) == -1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDLconst [c] (MOVLconst [d]))
}
b = l.Block
v0 := b.NewValue0(l.Pos, Op386CMPBconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(c, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = l.Block
v0 := b.NewValue0(l.Pos, Op386CMPLconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(c, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = l.Block
v0 := b.NewValue0(l.Pos, Op386CMPWconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(c, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, Op386MOVBLSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, Op386MOVBload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, Op386MOVBloadidx1, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg3(ptr, idx, mem)
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVLload [off1] {sym} (ADDLconst [off2] ptr) mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, Op386MOVWLSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, Op386MOVWload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg3(ptr, idx, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, Op386MOVWloadidx2, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg3(ptr, idx, mem)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MULLconst [3] x)
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORL x0:(MOVBload [i0] {s} p mem) s0:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)))
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, Op386MOVWload, typ.UInt16)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x2.Pos, Op386MOVLload, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORLconst [c] _)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SARBconst [c] (MOVLconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SARLconst [c] (MOVLconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SARWconst [c] (MOVLconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SUBLconst [c] x)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (XORLconst [c] (MOVLconst [d]))
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] destptr mem)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDLconst [c] (MOVLconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDQconst [c] (MOVQconst [d]))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDL x l:(MOVLload [off] {sym} ptr mem))
if !(int32(c) == -1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDLconst [c] (MOVLconst [d]))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDQ x l:(MOVQload [off] {sym} ptr mem))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDQconst [c] (MOVQconst [d]))
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLCC _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLCC y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLCC y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLCC _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLCS y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLCS _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLCS _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLCS y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLEQ y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLEQ y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLEQ y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLEQ y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLGE _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLGE _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLGE y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLGE y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLGT _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLGT _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLGT y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLGT y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLHI _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLHI y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLHI y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLHI _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLLE y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLLE y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLLE _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLLE _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLLS y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLLS _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLLS _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLLS y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLLT y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLLT y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLLT _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLLT _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVLNE _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLNE _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLNE _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVLNE _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQCC _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQCC y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQCC y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQCC _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQCS y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQCS _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQCS _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQCS y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQEQ y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQEQ y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQEQ y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQEQ y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQEQ x _ (Select1 (BSFQ (ORQconst [c] _))))
if !(c != 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQGE _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQGE _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQGE y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQGE y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQGT _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQGT _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQGT y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQGT y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQHI _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQHI y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQHI y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQHI _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQLE y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQLE y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQLE _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQLE _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQLS y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQLS _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQLS _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQLS y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQLT y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQLT y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQLT _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQLT _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVQNE _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQNE _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQNE _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVQNE _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWCC _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWCC y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWCC y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWCC _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWCS y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWCS _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWCS _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWCS y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWEQ y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWEQ y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWEQ y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWEQ y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWGE _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWGE _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWGE y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWGE y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWGT _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWGT _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWGT y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWGT y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWHI _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWHI y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWHI y _ (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWHI _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWLE y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWLE y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWLE _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWLE _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWLS y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWLS _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWLS _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWLS y _ (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWLT y _ (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWLT y _ (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWLT _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWLT _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpAMD64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CMOVWNE _ x (FlagGT_UGT))
if v_2.Op != OpAMD64FlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWNE _ x (FlagGT_ULT))
if v_2.Op != OpAMD64FlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWNE _ x (FlagLT_ULT))
if v_2.Op != OpAMD64FlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWNE _ x (FlagLT_UGT))
if v_2.Op != OpAMD64FlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
}
b = l.Block
v0 := b.NewValue0(l.Pos, OpAMD64CMPBconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(c, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = l.Block
v0 := b.NewValue0(l.Pos, OpAMD64CMPLconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(c, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = l.Block
v0 := b.NewValue0(l.Pos, OpAMD64CMPQconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(c, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = l.Block
v0 := b.NewValue0(l.Pos, OpAMD64CMPWconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(c, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVBQSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVBQSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVBQSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVBQSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVBload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVBload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVBload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVBload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
if !(zeroUpper56Bits(x, 3)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBQZX x:(MOVBloadidx1 [off] {sym} ptr idx mem))
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpAMD64MOVBloadidx1, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg3(ptr, idx, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVLQSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVLQSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVLload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVLload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
if !(zeroUpper32Bits(x, 3)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVLQZX x:(MOVLloadidx1 [off] {sym} ptr idx mem))
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpAMD64MOVLloadidx1, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg3(ptr, idx, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpAMD64MOVLloadidx4, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg3(ptr, idx, mem)
}
b = b.Func.Entry
v0 := b.NewValue0(v.Pos, OpArg, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
return true
}
b = b.Func.Entry
v0 := b.NewValue0(v.Pos, OpArg, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
return true
}
b = b.Func.Entry
v0 := b.NewValue0(v.Pos, OpArg, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
return true
}
b = b.Func.Entry
v0 := b.NewValue0(v.Pos, OpArg, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
return true
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVQload [off1] {sym} (ADDQconst [off2] ptr) mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVWQSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVWQSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVWQSXload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVWload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVWload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpAMD64MOVWload, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
if !(zeroUpper48Bits(x, 3)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWQZX x:(MOVWloadidx1 [off] {sym} ptr idx mem))
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx1, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg3(ptr, idx, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx2, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg3(ptr, idx, mem)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MULLconst [ 3] x)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MULQconst [ 3] x)
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (NEGL s:(SUBL x y))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (NEGQ s:(SUBQ x y))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORL x0:(MOVBload [i0] {s} p mem) sh:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)))
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpAMD64MOVWload, typ.UInt16)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpAMD64MOVLload, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x0.Pos, OpAMD64ORL, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpAMD64SHLLconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(x0.Pos, OpAMD64MOVWload, typ.UInt16)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx1, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64MOVLloadidx1, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpAMD64ORL, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpAMD64SHLLconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx1, typ.UInt16)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpAMD64ROLWconst, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = 8
v1 := b.NewValue0(x0.Pos, OpAMD64MOVWload, typ.UInt16)
v1.AuxInt = i0
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpAMD64BSWAPL, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpAMD64MOVLload, typ.UInt32)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x1.Pos, OpAMD64ORL, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpAMD64SHLLconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(x1.Pos, OpAMD64ROLWconst, typ.UInt16)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64ROLWconst, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = 8
v1 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx1, typ.UInt16)
v1.AuxInt = i0
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64BSWAPL, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVLloadidx1, typ.UInt32)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpAMD64ORL, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpAMD64SHLLconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(v.Pos, OpAMD64ROLWconst, typ.UInt16)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORLconst [c] _)
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORQ x0:(MOVBload [i0] {s} p mem) sh:(SHLQconst [8] x1:(MOVBload [i1] {s} p mem)))
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpAMD64MOVWload, typ.UInt16)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpAMD64MOVLload, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpAMD64MOVQload, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x0.Pos, OpAMD64ORQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpAMD64SHLQconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(x0.Pos, OpAMD64MOVWload, typ.UInt16)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x0.Pos, OpAMD64ORQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpAMD64SHLQconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(x0.Pos, OpAMD64MOVLload, typ.UInt32)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx1, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64MOVLloadidx1, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQloadidx1, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpAMD64ORQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpAMD64SHLQconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx1, typ.UInt16)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpAMD64ORQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpAMD64SHLQconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(v.Pos, OpAMD64MOVLloadidx1, typ.UInt32)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpAMD64ROLWconst, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = 8
v1 := b.NewValue0(x0.Pos, OpAMD64MOVWload, typ.UInt16)
v1.AuxInt = i0
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpAMD64BSWAPL, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpAMD64MOVLload, typ.UInt32)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpAMD64BSWAPQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpAMD64MOVQload, typ.UInt64)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x1.Pos, OpAMD64ORQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpAMD64SHLQconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(x1.Pos, OpAMD64ROLWconst, typ.UInt16)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x1.Pos, OpAMD64ORQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpAMD64SHLQconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(x1.Pos, OpAMD64BSWAPL, typ.UInt32)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64ROLWconst, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = 8
v1 := b.NewValue0(v.Pos, OpAMD64MOVWloadidx1, typ.UInt16)
v1.AuxInt = i0
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64BSWAPL, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVLloadidx1, typ.UInt32)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64BSWAPQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQloadidx1, typ.UInt64)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpAMD64ORQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpAMD64SHLQconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(v.Pos, OpAMD64ROLWconst, typ.UInt16)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpAMD64ORQ, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpAMD64SHLQconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(v.Pos, OpAMD64BSWAPL, typ.UInt32)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORQconst [-1] _)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SARBconst [c] (MOVQconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SARLconst [c] (MOVQconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SARQconst [c] (MOVQconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SARWconst [c] (MOVQconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SHLLconst [d] (MOVLconst [c]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SHLQconst [d] (MOVQconst [c]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SUBLconst [c] x)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SUBQconst [c] x)
}
b = l.Block
v0 := b.NewValue0(l.Pos, OpAMD64CMPBconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(0, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = l.Block
v0 := b.NewValue0(l.Pos, OpAMD64CMPLconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(0, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = l.Block
v0 := b.NewValue0(l.Pos, OpAMD64CMPQconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(0, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = l.Block
v0 := b.NewValue0(l.Pos, OpAMD64CMPWconstload, types.TypeFlags)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = makeValAndOff(0, off)
v0.Aux = sym
v0.AddArg2(ptr, mem)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (XORLconst [c] (MOVLconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (XORQconst [c] (MOVQconst [d]))
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
break
}
x := v_0_0_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Select1 (AddTupleFirst32 _ tuple))
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] destptr mem)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDconst [c] x)
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (AND x (MVN y))
if !(int32(c) == -1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDconst [c] x)
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (BICconst [c] _)
if v_1.Op != OpARMFlagLT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWHSconst _ (FlagLT_UGT) [c])
if v_1.Op != OpARMFlagGT_ULT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWHSconst _ (FlagGT_UGT) [c])
if v_1.Op != OpARMFlagLT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWLSconst _ (FlagGT_ULT) [c])
if v_1.Op != OpARMFlagGT_UGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CMOVWLSconst x (InvertFlags flags) [c])
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWload [0] {sym} (ADD ptr idx) mem)
if !(isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWloadidx ptr (MOVWconst [c]) mem)
if !(c == d && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWloadshiftLL ptr (MOVWconst [c]) [d] mem)
if !(c == d && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWloadshiftRA ptr (MOVWconst [c]) [d] mem)
if !(c == d && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWloadshiftRL ptr (MOVWconst [c]) [d] mem)
if v_1.Op != OpARMMOVWconst || v_1.AuxInt != 1 {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
break
}
a := v_2
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MULA x (MOVWconst [1]) a)
break
}
a := v_2
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MULA (MOVWconst [1]) x a)
break
}
a := v_2
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MULS x (MOVWconst [1]) a)
break
}
a := v_2
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MULS (MOVWconst [1]) x a)
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORconst [c] _)
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SUBconst [c] x)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (XORconst [c] (MOVWconst [d]))
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
if v_0_1.Op != OpARMMOVWconst || v_0_1.AuxInt != 1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Select0 (CALLudiv x (MOVWconst [c])))
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] ptr mem)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDconst [c] (MOVDconst [d]))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (AND x (MVN y))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDconst [c] (MOVDconst [d]))
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if !(ccARM64Eval(cc, flag) > 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CSEL {cc} _ y flag)
if !(ccARM64Eval(cc, flag) < 0) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (CSEL {cc} x y (CMPWconst [0] boolval))
if !(ccARM64Eval(cc, flag) > 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (CSEL0 {cc} _ flag)
sym := v_0.Aux
b = b.Func.Entry
v0 := b.NewValue0(v.Pos, OpArg, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
return true
sym := v_0.Aux
b = b.Func.Entry
v0 := b.NewValue0(v.Pos, OpArg, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
return true
if v_2.Op != OpARM64MOVDconst || v_2.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MADD a x (MOVDconst [1]))
if v_1.Op != OpARM64MOVDconst || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MADD a (MOVDconst [1]) x)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MADDW a x (MOVDconst [c]))
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MADDW a (MOVDconst [c]) x)
if v_1.Op != OpARM64MOVDconst || v_1.AuxInt != -1 {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if !(int32(c) == -1) {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if v_2.Op != OpARM64MOVDconst || v_2.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MSUB a x (MOVDconst [1]))
if v_1.Op != OpARM64MOVDconst || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MSUB a (MOVDconst [1]) x)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MSUBW a x (MOVDconst [c]))
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (MSUBW a (MOVDconst [c]) x)
if v_1.Op != OpARM64MOVDconst || v_1.AuxInt != 1 {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if !(int32(c) == 1) {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (OR x (MVN y))
}
b = mergePoint(b, x0, x1, x2, x3)
v0 := b.NewValue0(x3.Pos, OpARM64MOVWUload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.Aux = s
v1 := b.NewValue0(x3.Pos, OpOffPtr, p.Type)
v1.AuxInt = i0
}
b = mergePoint(b, x0, x1, x2, x3)
v0 := b.NewValue0(x2.Pos, OpARM64MOVWUloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr0, idx0, mem)
return true
}
}
b = mergePoint(b, x0, x1, x2, x3)
v0 := b.NewValue0(v.Pos, OpARM64MOVWUloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr, idx, mem)
return true
}
}
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
v0 := b.NewValue0(x7.Pos, OpARM64MOVDload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.Aux = s
v1 := b.NewValue0(x7.Pos, OpOffPtr, p.Type)
v1.AuxInt = i0
}
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
v0 := b.NewValue0(x6.Pos, OpARM64MOVDloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr0, idx0, mem)
return true
}
}
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
v0 := b.NewValue0(v.Pos, OpARM64MOVDloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr, idx, mem)
return true
}
}
b = mergePoint(b, x0, x1, x2, x3)
v0 := b.NewValue0(x3.Pos, OpARM64REVW, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x3.Pos, OpARM64MOVWUload, t)
v1.Aux = s
v2 := b.NewValue0(x3.Pos, OpOffPtr, p.Type)
}
b = mergePoint(b, x0, x1, x2, x3)
v0 := b.NewValue0(x3.Pos, OpARM64REVW, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x3.Pos, OpARM64MOVWUloadidx, t)
v1.AddArg3(ptr0, idx0, mem)
v0.AddArg(v1)
}
b = mergePoint(b, x0, x1, x2, x3)
v0 := b.NewValue0(v.Pos, OpARM64REVW, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVWUloadidx, t)
v1.AddArg3(ptr, idx, mem)
v0.AddArg(v1)
}
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
v0 := b.NewValue0(x7.Pos, OpARM64REV, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x7.Pos, OpARM64MOVDload, t)
v1.Aux = s
v2 := b.NewValue0(x7.Pos, OpOffPtr, p.Type)
}
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
v0 := b.NewValue0(x7.Pos, OpARM64REV, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x7.Pos, OpARM64MOVDloadidx, t)
v1.AddArg3(ptr0, idx0, mem)
v0.AddArg(v1)
}
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
v0 := b.NewValue0(v.Pos, OpARM64REV, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVDloadidx, t)
v1.AddArg3(ptr, idx, mem)
v0.AddArg(v1)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORconst [-1] _)
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: ( ORshiftLL [c] (SRLconst x [64-c]) x)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpARM64MOVHUload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.Aux = s
v1 := b.NewValue0(x1.Pos, OpOffPtr, p.Type)
v1.AuxInt = i0
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpARM64MOVHUloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr0, idx0, mem)
return true
}
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpARM64MOVHUloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr, idx, mem)
return true
}
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x2.Pos, OpARM64MOVWUload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.Aux = s
v1 := b.NewValue0(x2.Pos, OpOffPtr, p.Type)
v1.AuxInt = i0
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x2.Pos, OpARM64MOVWUloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr0, idx0, mem)
return true
}
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(v.Pos, OpARM64MOVWUloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr, idx, mem)
return true
}
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x2.Pos, OpARM64MOVWUloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x2.Pos, OpARM64SLLconst, idx0.Type)
v1.AuxInt = 1
v1.AddArg(idx0)
}
b = mergePoint(b, x0, x1, x2, x3, x4)
v0 := b.NewValue0(x4.Pos, OpARM64MOVDload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.Aux = s
v1 := b.NewValue0(x4.Pos, OpOffPtr, p.Type)
v1.AuxInt = i0
}
b = mergePoint(b, x0, x1, x2, x3, x4)
v0 := b.NewValue0(x4.Pos, OpARM64MOVDloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr0, idx0, mem)
return true
}
}
b = mergePoint(b, x0, x1, x2, x3, x4)
v0 := b.NewValue0(x4.Pos, OpARM64MOVDloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x4.Pos, OpARM64SLLconst, idx0.Type)
v1.AuxInt = 2
v1.AddArg(idx0)
}
b = mergePoint(b, x0, x1, x2, x3, x4)
v0 := b.NewValue0(v.Pos, OpARM64MOVDloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AddArg3(ptr, idx, mem)
return true
}
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpARM64REV16W, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpARM64MOVHUload, t)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpARM64REV16W, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpARM64MOVHUloadidx, t)
v1.AddArg3(ptr0, idx0, mem)
v0.AddArg(v1)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpARM64REV16W, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVHUloadidx, t)
v1.AddArg3(ptr, idx, mem)
v0.AddArg(v1)
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x2.Pos, OpARM64REVW, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x2.Pos, OpARM64MOVWUload, t)
v1.Aux = s
v2 := b.NewValue0(x2.Pos, OpOffPtr, p.Type)
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x1.Pos, OpARM64REVW, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpARM64MOVWUloadidx, t)
v1.AddArg3(ptr0, idx0, mem)
v0.AddArg(v1)
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(v.Pos, OpARM64REVW, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVWUloadidx, t)
v1.AddArg3(ptr, idx, mem)
v0.AddArg(v1)
}
b = mergePoint(b, x0, x1, x2, x3, x4)
v0 := b.NewValue0(x4.Pos, OpARM64REV, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x4.Pos, OpARM64MOVDload, t)
v1.Aux = s
v2 := b.NewValue0(x4.Pos, OpOffPtr, p.Type)
}
b = mergePoint(b, x0, x1, x2, x3, x4)
v0 := b.NewValue0(x3.Pos, OpARM64REV, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x3.Pos, OpARM64MOVDloadidx, t)
v1.AddArg3(ptr0, idx0, mem)
v0.AddArg(v1)
}
b = mergePoint(b, x0, x1, x2, x3, x4)
v0 := b.NewValue0(v.Pos, OpARM64REV, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVDloadidx, t)
v1.AddArg3(ptr, idx, mem)
v0.AddArg(v1)
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
return false
if x != y.Args[0] || !(c == d) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: ( ORshiftRL [c] (SLLconst x [64-c]) x)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SUBconst [c] (MOVDconst [d]))
if v_1.Op != OpARM64MOVDconst || v_1.AuxInt != 1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (UDIV x (MOVDconst [c]))
if !(uint32(c) == 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (UDIVW x (MOVDconst [c]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (XORconst [-1] x)
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] ptr mem)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDconst [c] (MOVWconst [d]))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (AND (SGTUconst [1] x) (SGTUconst [1] y))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDconst [c] (MOVWconst [d]))
if v_2.Op != OpMIPSMOVWconst || v_2.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = f.Type
- v.AddArg(f)
+ v.copyOf(f)
return true
}
// match: (CMOVZ a _ (MOVWconst [c]))
if !(c != 0) {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
// match: (CMOVZ a (MOVWconst [0]) c)
if !(c != 0) {
break
}
- v.reset(OpCopy)
- v.Type = a.Type
- v.AddArg(a)
+ v.copyOf(a)
return true
}
return false
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpMIPSMOVBUload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpMIPSMOVBload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpMIPSMOVHUload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpMIPSMOVHload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (OR (SGTUzero x) (SGTUzero y))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORconst [-1] _)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SUBconst [c] (MOVWconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (XORconst [-1] x)
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
continue
}
x := v_0_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] ptr mem)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDVconst [c] (MOVVconst [d]))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDconst [c] (MOVVconst [d]))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORconst [-1] _)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SUBVconst [c] (MOVVconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (XORconst [-1] x)
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
if v_0_1.Op != OpMIPS64MOVVconst || v_0_1.AuxInt != 1 {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if v_0_1.Op != OpMIPS64MOVVconst || v_0_1.AuxInt != 1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Select1 (DIVVU x (MOVVconst [c])))
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] ptr mem)
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDconst [c] (MOVDaddr [d] {sym} x))
if y.Op != OpPPC64MOVWZreg || !(c&0xFFFFFFFF == 0xFFFFFFFF) {
continue
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
break
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDconst [0] _)
if y.Op != OpPPC64MOVBZreg || !(c&0xFF == 0xFF) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ANDconst [0xFF] y:(MOVBreg _))
if y.Op != OpPPC64MOVBreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ANDconst [c] y:(MOVHZreg _))
if y.Op != OpPPC64MOVHZreg || !(c&0xFFFF == 0xFFFF) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ANDconst [0xFFFF] y:(MOVHreg _))
if y.Op != OpPPC64MOVHreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ANDconst [c] (MOVBreg x))
if v_2.Op != OpPPC64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ISEL [2] _ y (FlagLT))
if v_2.Op != OpPPC64FlagLT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ISEL [2] _ y (FlagGT))
if v_2.Op != OpPPC64FlagGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ISEL [6] _ y (FlagEQ))
if v_2.Op != OpPPC64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ISEL [6] x _ (FlagLT))
if v_2.Op != OpPPC64FlagLT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ISEL [6] x _ (FlagGT))
if v_2.Op != OpPPC64FlagGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ISEL [0] _ y (FlagEQ))
if v_2.Op != OpPPC64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ISEL [0] _ y (FlagGT))
if v_2.Op != OpPPC64FlagGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ISEL [0] x _ (FlagLT))
if v_2.Op != OpPPC64FlagLT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ISEL [5] _ x (FlagEQ))
if v_2.Op != OpPPC64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ISEL [5] _ x (FlagLT))
if v_2.Op != OpPPC64FlagLT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ISEL [5] y _ (FlagGT))
if v_2.Op != OpPPC64FlagGT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ISEL [1] _ y (FlagEQ))
if v_2.Op != OpPPC64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ISEL [1] _ y (FlagLT))
if v_2.Op != OpPPC64FlagLT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ISEL [1] x _ (FlagGT))
if v_2.Op != OpPPC64FlagGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ISEL [4] x _ (FlagEQ))
if v_2.Op != OpPPC64FlagEQ {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ISEL [4] x _ (FlagGT))
if v_2.Op != OpPPC64FlagGT {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ISEL [4] _ y (FlagLT))
if v_2.Op != OpPPC64FlagLT {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (ISEL [n] x y (InvertFlags bool))
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpPPC64MOVDload, typ.Int64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
if !(uint64(c) <= 0xFF) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVBZreg (SRWconst [c] (MOVBZreg x)))
if y.Op != OpPPC64MOVBZreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVBZreg (MOVBreg x))
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBZreg x:(MOVBZloadidx _ _ _))
break
}
_ = x.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBZreg x:(Arg <t>))
if !(is8BitInt(t) && !isSigned(t)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBZreg (MOVDconst [c]))
if !(uint64(c) <= 0x7F) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVBreg (SRAWconst [c] (MOVBreg x)))
if y.Op != OpPPC64MOVBreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVBreg (MOVBZreg x))
if !(is8BitInt(t) && isSigned(t)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBreg (MOVDconst [c]))
if !(uint64(c) <= 0xFFFF) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVHZreg (SRWconst [c] (MOVBZreg x)))
if y.Op != OpPPC64MOVHZreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVHZreg y:(MOVBZreg _))
if y.Op != OpPPC64MOVBZreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVHZreg y:(MOVHBRload _ _))
break
}
_ = y.Args[1]
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVHZreg y:(MOVHreg x))
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg x:(MOVBZloadidx _ _ _))
break
}
_ = x.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg x:(MOVHZload _ _))
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg x:(MOVHZloadidx _ _ _))
break
}
_ = x.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg x:(Arg <t>))
if !((is8BitInt(t) || is16BitInt(t)) && !isSigned(t)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg (MOVDconst [c]))
if !(uint64(c) <= 0x7FFF) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVHreg (SRAWconst [c] (MOVBreg x)))
if y.Op != OpPPC64MOVHreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVHreg y:(MOVBreg _))
if y.Op != OpPPC64MOVBreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVHreg y:(MOVHZreg x))
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg x:(MOVHloadidx _ _ _))
break
}
_ = x.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg x:(Arg <t>))
if !((is8BitInt(t) || is16BitInt(t)) && isSigned(t)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg (MOVDconst [c]))
if !(uint64(c) <= 0xFFFFFFFF) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWZreg y:(AND (MOVDconst [c]) _))
if !(uint64(c) <= 0xFFFFFFFF) {
continue
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
break
if y.Op != OpPPC64MOVWZreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWZreg y:(MOVHZreg _))
if y.Op != OpPPC64MOVHZreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWZreg y:(MOVBZreg _))
if y.Op != OpPPC64MOVBZreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWZreg y:(MOVHBRload _ _))
break
}
_ = y.Args[1]
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWZreg y:(MOVWBRload _ _))
break
}
_ = y.Args[1]
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWZreg y:(MOVWreg x))
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVBZloadidx _ _ _))
break
}
_ = x.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVHZload _ _))
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVHZloadidx _ _ _))
break
}
_ = x.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVWZload _ _))
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVWZloadidx _ _ _))
break
}
_ = x.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(Arg <t>))
if !((is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && !isSigned(t)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg (MOVDconst [c]))
if !(uint64(c) <= 0xFFFF) {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWreg y:(AND (MOVDconst [c]) _))
if !(uint64(c) <= 0x7FFFFFFF) {
continue
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
break
if y.Op != OpPPC64MOVWreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWreg y:(MOVHreg _))
if y.Op != OpPPC64MOVHreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWreg y:(MOVBreg _))
if y.Op != OpPPC64MOVBreg {
break
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
// match: (MOVWreg y:(MOVWZreg x))
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVHloadidx _ _ _))
break
}
_ = x.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVWload _ _))
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVWloadidx _ _ _))
break
}
_ = x.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(Arg <t>))
if !((is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && isSigned(t)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg (MOVDconst [c]))
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpPPC64FMOVDload, typ.Float64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = off
v0.Aux = sym
v0.AddArg2(ptr, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpPPC64MOVHZload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpPPC64MOVHZload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpPPC64MOVHBRload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpPPC64MOVDaddr, typ.Uintptr)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpPPC64MOVHBRload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpPPC64MOVDaddr, typ.Uintptr)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpPPC64SLDconst, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = n1
v1 := b.NewValue0(x1.Pos, OpPPC64MOVHBRload, t)
v2 := b.NewValue0(x1.Pos, OpPPC64MOVDaddr, typ.Uintptr)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpPPC64SLDconst, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = n1
v1 := b.NewValue0(x1.Pos, OpPPC64MOVHBRload, t)
v2 := b.NewValue0(x1.Pos, OpPPC64MOVDaddr, typ.Uintptr)
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x0.Pos, OpPPC64MOVWZload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x0.Pos, OpPPC64MOVWZload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x0.Pos, OpPPC64MOVWBRload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpPPC64MOVDaddr, typ.Uintptr)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x0.Pos, OpPPC64MOVWBRload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpPPC64MOVDaddr, typ.Uintptr)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x2.Pos, OpPPC64MOVWBRload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x2.Pos, OpPPC64MOVDaddr, typ.Uintptr)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x2.Pos, OpPPC64MOVWBRload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x2.Pos, OpPPC64MOVDaddr, typ.Uintptr)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x0.Pos, OpPPC64SLDconst, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = 32
v1 := b.NewValue0(x0.Pos, OpPPC64MOVWBRload, t)
v2 := b.NewValue0(x0.Pos, OpPPC64MOVDaddr, typ.Uintptr)
}
b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(x0.Pos, OpPPC64SLDconst, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = 32
v1 := b.NewValue0(x0.Pos, OpPPC64MOVWBRload, t)
v2 := b.NewValue0(x0.Pos, OpPPC64MOVDaddr, typ.Uintptr)
}
b = mergePoint(b, x0, x4, x5, x6, x7)
v0 := b.NewValue0(x0.Pos, OpPPC64MOVDload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, x2, x3, x4)
v0 := b.NewValue0(x4.Pos, OpPPC64MOVDBRload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x4.Pos, OpPPC64MOVDaddr, typ.Uintptr)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x3, x4, x5, x6, x7)
v0 := b.NewValue0(x3.Pos, OpPPC64MOVDBRload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x3.Pos, OpPPC64MOVDaddr, typ.Uintptr)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x3, x4, x5, x6, x7)
v0 := b.NewValue0(x3.Pos, OpPPC64MOVDBRload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x3.Pos, OpPPC64MOVDaddr, typ.Uintptr)
v1.AuxInt = i0
v1.Aux = s
if v_1.Op != OpPPC64MOVDconst || v_1.AuxInt != -1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] destptr mem)
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] ptr mem)
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDWconst [c] (MOVDconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ADDconst [c] (MOVDconst [d]))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (AND <t> x g:(MOVDload [off] {sym} ptr mem))
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDW <t> x g:(MOVWload [off] {sym} ptr mem))
if !(int32(c) == -1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDWconst [c] (MOVDconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ANDconst [c] (MOVDconst [d]))
if !(isSamePtr(ptr1, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
if !(isSamePtr(ptr1, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpS390XLNDFR, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x.Pos, OpS390XLDGR, t)
v2 := b.NewValue0(x.Pos, OpS390XMOVDload, t1)
v2.AuxInt = off
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_2.Op != OpS390XFlagEQ || !(c.(s390x.CCMask)&s390x.Equal != 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (LOCGR {c} _ x (FlagLT))
if v_2.Op != OpS390XFlagLT || !(c.(s390x.CCMask)&s390x.Less != 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (LOCGR {c} _ x (FlagGT))
if v_2.Op != OpS390XFlagGT || !(c.(s390x.CCMask)&s390x.Greater != 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (LOCGR {c} _ x (FlagOV))
if v_2.Op != OpS390XFlagOV || !(c.(s390x.CCMask)&s390x.Unordered != 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (LOCGR {c} x _ (FlagEQ))
if v_2.Op != OpS390XFlagEQ || !(c.(s390x.CCMask)&s390x.Equal == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (LOCGR {c} x _ (FlagLT))
if v_2.Op != OpS390XFlagLT || !(c.(s390x.CCMask)&s390x.Less == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (LOCGR {c} x _ (FlagGT))
if v_2.Op != OpS390XFlagGT || !(c.(s390x.CCMask)&s390x.Greater == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (LOCGR {c} x _ (FlagOV))
if v_2.Op != OpS390XFlagOV || !(c.(s390x.CCMask)&s390x.Unordered == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if x.Op != OpS390XFMOVSconst {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if x.Op != OpS390XFMOVDconst {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBZreg x:(MOVBZloadidx _ _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBZreg <t> x:(MOVBload [o] {s} p mem))
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpS390XMOVBZload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg2(p, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg3(p, i, mem)
if !(!t.IsSigned() && t.Size() == 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBZreg (MOVDconst [c]))
if !(int64(uint8(c)) == c && int64(uint8(d)) == d && (!x.Type.IsSigned() || x.Type.Size() > 1)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBZreg (ANDWconst [m] x))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBreg x:(MOVBloadidx _ _ _))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBreg <t> x:(MOVBZload [o] {s} p mem))
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpS390XMOVBload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg2(p, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg3(p, i, mem)
if !(t.IsSigned() && t.Size() == 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVBreg (MOVDconst [c]))
if !(isSamePtr(ptr1, ptr2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVDload [off] {sym} ptr1 (FMOVDstore [off] {sym} ptr2 x _))
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg x:(MOVBZloadidx _ _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg x:(MOVHZload _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 2) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg x:(MOVHZloadidx _ _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 2) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg <t> x:(MOVHload [o] {s} p mem))
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpS390XMOVHZload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg2(p, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg3(p, i, mem)
if !(!t.IsSigned() && t.Size() <= 2) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHZreg (MOVDconst [c]))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg x:(MOVBloadidx _ _ _))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg x:(MOVHload _ _))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg x:(MOVHloadidx _ _ _))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg x:(MOVBZload _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg x:(MOVBZloadidx _ _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg <t> x:(MOVHZload [o] {s} p mem))
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpS390XMOVHload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg2(p, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpS390XMOVHloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg3(p, i, mem)
if !(t.IsSigned() && t.Size() <= 2) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVHreg (MOVDconst [c]))
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVBZloadidx _ _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVHZload _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 2) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVHZloadidx _ _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 2) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVWZload _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 4) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg x:(MOVWZloadidx _ _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 4) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg <t> x:(MOVWload [o] {s} p mem))
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpS390XMOVWZload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg2(p, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg3(p, i, mem)
if !(!t.IsSigned() && t.Size() <= 4) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWZreg (MOVDconst [c]))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVBloadidx _ _ _))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVHload _ _))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVHloadidx _ _ _))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVWload _ _))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVWloadidx _ _ _))
if !(x.Type.IsSigned() || x.Type.Size() == 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVBZload _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVBZloadidx _ _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 1) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVHZload _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 2) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg x:(MOVHZloadidx _ _ _))
if !(!x.Type.IsSigned() || x.Type.Size() > 2) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg <t> x:(MOVWZload [o] {s} p mem))
}
b = x.Block
v0 := b.NewValue0(x.Pos, OpS390XMOVWload, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg2(p, mem)
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpS390XMOVWloadidx, t)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = o
v0.Aux = s
v0.AddArg3(p, i, mem)
if !(t.IsSigned() && t.Size() <= 4) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MOVWreg (MOVDconst [c]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MULLDconst [c] x)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (MULLWconst [c] x)
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (OR <t> x g:(MOVDload [off] {sym} ptr mem))
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpS390XMOVHZload, typ.UInt16)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpS390XMOVWZload, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpS390XMOVDload, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x1.Pos, OpS390XOR, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpS390XSLDconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(x1.Pos, OpS390XMOVWZload, typ.UInt32)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpS390XMOVHZreg, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpS390XMOVHBRload, typ.UInt16)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpS390XMOVWZreg, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpS390XMOVWBRload, typ.UInt32)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpS390XMOVDBRload, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x0.Pos, OpS390XOR, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpS390XSLDconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(x0.Pos, OpS390XMOVWZreg, typ.UInt64)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORW <t> x g:(MOVWload [off] {sym} ptr mem))
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpS390XMOVHZload, typ.UInt16)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x0.Pos, OpS390XMOVWZload, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x1.Pos, OpS390XORW, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpS390XSLWconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(x1.Pos, OpS390XMOVHZload, typ.UInt16)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
v1.AuxInt = j1
v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpS390XMOVHZreg, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x1.Pos, OpS390XMOVHBRload, typ.UInt16)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(x1.Pos, OpS390XMOVWBRload, typ.UInt32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg2(p, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(x0.Pos, OpS390XORW, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(x0.Pos, OpS390XSLWconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(x0.Pos, OpS390XMOVHZreg, typ.UInt64)
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
v1.AuxInt = i0
v1.Aux = s
}
b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v0.AuxInt = i0
v0.Aux = s
v0.AddArg3(p, idx, mem)
}
b = mergePoint(b, x0, x1, y)
v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
v1.AuxInt = j0
v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORWconst [c] _)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ORconst [-1] _)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SUBWconst [c] x)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SUBconst [c] x)
if !(int32(c) == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (XORWconst [c] (MOVDconst [d]))
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (XORconst [c] (MOVDconst [d]))
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] destptr mem)
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Move [1] dst src mem)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SignExt16to32 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SignExt16to64 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SignExt32to64 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SignExt8to16 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SignExt8to32 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (SignExt8to64 x)
break
}
x := v_0
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (I64AddConst [off] (LoweredAddr {sym} [off2] base))
break
}
mem := v_1
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero [1] destptr mem)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ZeroExt16to32 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ZeroExt16to64 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ZeroExt32to64 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ZeroExt8to16 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ZeroExt8to32 x)
break
}
_ = x.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ZeroExt8to64 x)
break
}
imag := v_0.Args[1]
- v.reset(OpCopy)
- v.Type = imag.Type
- v.AddArg(imag)
+ v.copyOf(imag)
return true
}
return false
}
_ = v_0.Args[1]
real := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = real.Type
- v.AddArg(real)
+ v.copyOf(real)
return true
}
return false
break
}
data := v_0.Args[1]
- v.reset(OpCopy)
- v.Type = data.Type
- v.AddArg(data)
+ v.copyOf(data)
return true
}
return false
}
_ = v_0.Args[1]
itab := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = itab.Type
- v.AddArg(itab)
+ v.copyOf(itab)
return true
}
return false
break
}
cap := v_0.Args[2]
- v.reset(OpCopy)
- v.Type = cap.Type
- v.AddArg(cap)
+ v.copyOf(cap)
return true
}
return false
}
_ = v_0.Args[2]
len := v_0.Args[1]
- v.reset(OpCopy)
- v.Type = len.Type
- v.AddArg(len)
+ v.copyOf(len)
return true
}
return false
}
_ = v_0.Args[2]
ptr := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = ptr.Type
- v.AddArg(ptr)
+ v.copyOf(ptr)
return true
}
return false
break
}
len := v_0.Args[1]
- v.reset(OpCopy)
- v.Type = len.Type
- v.AddArg(len)
+ v.copyOf(len)
return true
}
return false
}
_ = v_0.Args[1]
ptr := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = ptr.Type
- v.AddArg(ptr)
+ v.copyOf(ptr)
return true
}
return false
}
_ = v_0.Args[1]
hi := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = hi.Type
- v.AddArg(hi)
+ v.copyOf(hi)
return true
}
return false
break
}
lo := v_0.Args[1]
- v.reset(OpCopy)
- v.Type = lo.Type
- v.AddArg(lo)
+ v.copyOf(lo)
return true
}
return false
break
}
lo := v_0.Args[1]
- v.reset(OpCopy)
- v.Type = lo.Type
- v.AddArg(lo)
+ v.copyOf(lo)
return true
}
return false
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (And16 (Const16 [-1]) x)
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (And32 (Const32 [-1]) x)
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (And64 (Const64 [-1]) x)
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (And8 (Const8 [-1]) x)
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (ArraySelect [0] (IData x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Com16 (Const16 [c]))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Com32 (Const32 [c]))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Com64 (Const64 [c]))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Com8 (Const8 [c]))
if mem != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = ptr.Type
- v.AddArg(ptr)
+ v.copyOf(ptr)
return true
}
return false
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if !(isSamePtr(p1, p2) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 x _)))
if !(isSamePtr(p1, p3) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p3, sizeof(t3), p2, sizeof(t2))) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 x _))))
if !(isSamePtr(p1, p4) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p4, sizeof(t4), p2, sizeof(t2)) && disjoint(p4, sizeof(t4), p3, sizeof(t3))) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 x _)))))
if !(isSamePtr(p1, p5) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p5, sizeof(t5), p2, sizeof(t2)) && disjoint(p5, sizeof(t5), p3, sizeof(t3)) && disjoint(p5, sizeof(t5), p4, sizeof(t4))) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Load <t1> p1 (Store {t2} p2 (Const64 [x]) _))
}
b = mem.Block
v0 := b.NewValue0(v.Pos, OpLoad, t1)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
v1.AuxInt = o1
v1.AddArg(p3)
}
b = mem.Block
v0 := b.NewValue0(v.Pos, OpLoad, t1)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
v1.AuxInt = o1
v1.AddArg(p4)
}
b = mem.Block
v0 := b.NewValue0(v.Pos, OpLoad, t1)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
v1.AuxInt = o1
v1.AddArg(p5)
}
b = mem.Block
v0 := b.NewValue0(v.Pos, OpLoad, t1)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
v1.AuxInt = o1
v1.AddArg(p6)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Lsh16x64 (Const16 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Lsh32x64 (Const32 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Lsh64x64 (Const64 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Lsh8x64 (Const8 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != -1<<63 || !(isNonNegative(n)) {
break
}
- v.reset(OpCopy)
- v.Type = n.Type
- v.AddArg(n)
+ v.copyOf(n)
return true
}
// match: (Mod64 <t> n (Const64 [c]))
if !(isSamePtr(dst, src)) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
return false
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if v_1.Op != OpConst32F || v_1.AuxInt != auxFrom64F(1) {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if v_1.Op != OpConst64F || v_1.AuxInt != auxFrom64F(1) {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Neg16 <t> (Com16 x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Neg32 <t> (Com32 x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Neg64 <t> (Com64 x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Neg8 <t> (Com8 x))
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if mem != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (NilCheck (Load (OffPtr [c] (SP)) (StaticCall {sym} _)) _)
if !(v.Type.Compare(p.Type) == types.CMPeq) {
break
}
- v.reset(OpCopy)
- v.Type = p.Type
- v.AddArg(p)
+ v.copyOf(p)
return true
}
return false
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Or16 (Const16 [0]) x)
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Or32 (Const32 [0]) x)
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Or64 (Const64 [0]) x)
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Or8 (Const8 [0]) x)
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if !(c%16 == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(c%32 == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(c%64 == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(c%8 == 0) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if x.Op != OpConst32F {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if x.Op != OpConst64F {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Rsh16Ux64 (Const16 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Rsh16x64 (Const16 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Rsh32Ux64 (Const32 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Rsh32x64 (Const32 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Rsh64Ux64 (Const64 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Rsh64x64 (Const64 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Rsh8Ux64 (Const8 [0]) _)
if v_1.Op != OpConst64 || v_1.AuxInt != 0 {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Rsh8x64 (Const8 [0]) _)
if !(s >= 16) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 48) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 32) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 24) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 56) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(needRaceCleanup(sym, v)) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if mem != v_2 || !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1)) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ oldmem))
if oldmem != mem.Args[2] || !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3))) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ oldmem)))
if oldmem != mem_2.Args[2] || !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4))) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ oldmem))))
if oldmem != mem_2_2.Args[2] || !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4)) && disjoint(p1, sizeof(t1), p5, sizeof(t5))) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store {t} (OffPtr [o] p1) x mem:(Zero [n] p2 _))
if !(isConstZero(x) && o >= 0 && sizeof(t)+o <= n && isSamePtr(p1, p2)) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Zero [n] p3 _)))
if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p3) && disjoint(op, sizeof(t1), p2, sizeof(t2))) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Zero [n] p4 _))))
if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p4) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3))) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Zero [n] p5 _)))))
if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p5) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3)) && disjoint(op, sizeof(t1), p4, sizeof(t4))) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store _ (StructMake0) mem)
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store dst (StructMake1 <t> f0) mem)
break
}
mem := v_2
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store dst (ArrayMake1 e) mem)
if mem != v_2 || !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
if mem != v_2 || !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Move [n] p3 _ mem)))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [0] (StructMake2 x _))
}
_ = v_0.Args[1]
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [1] (StructMake2 _ x))
break
}
x := v_0.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [0] (StructMake3 x _ _))
}
_ = v_0.Args[2]
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [1] (StructMake3 _ x _))
}
_ = v_0.Args[2]
x := v_0.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [2] (StructMake3 _ _ x))
break
}
x := v_0.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [0] (StructMake4 x _ _ _))
}
_ = v_0.Args[3]
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [1] (StructMake4 _ x _ _))
}
_ = v_0.Args[3]
x := v_0.Args[1]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [2] (StructMake4 _ _ x _))
}
_ = v_0.Args[3]
x := v_0.Args[2]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [3] (StructMake4 _ _ _ x))
break
}
x := v_0.Args[3]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (StructSelect [i] x:(Load <t> ptr mem))
}
b = x.Block
v0 := b.NewValue0(v.Pos, OpLoad, v.Type)
- v.reset(OpCopy)
- v.AddArg(v0)
+ v.copyOf(v0)
v1 := b.NewValue0(v.Pos, OpOffPtr, v.Type.PtrTo())
v1.AuxInt = t.FieldOff(int(i))
v1.AddArg(ptr)
if x != v_1 {
continue
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
break
if y != v_1 {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
continue
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
break
if y != v_1 {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
continue
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
break
if y != v_1 {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
if x != v_1 {
continue
}
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
break
if y != v_1 {
continue
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc16to8 (SignExt8to16 x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc16to8 (And16 (Const16 [y]) x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc32to16 (SignExt8to32 x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc32to16 (And32 (Const32 [y]) x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc32to8 (SignExt8to32 x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc32to8 (And32 (Const32 [y]) x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc64to16 (SignExt8to64 x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc64to16 (And64 (Const64 [y]) x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc64to32 (SignExt8to64 x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc64to32 (And64 (Const64 [y]) x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc64to8 (SignExt8to64 x))
break
}
x := v_0.Args[0]
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
// match: (Trunc64to8 (And64 (Const64 [y]) x))
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
y := v_1_1
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
}
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
y := v_1_1
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
}
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
y := v_1_1
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
}
continue
}
x := v_1
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
break
continue
}
y := v_1_1
- v.reset(OpCopy)
- v.Type = y.Type
- v.AddArg(y)
+ v.copyOf(y)
return true
}
}
if v_0_0_0.Op != OpSP || mem != v_1 || !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
break
}
- v.reset(OpCopy)
- v.Type = mem.Type
- v.AddArg(mem)
+ v.copyOf(mem)
return true
}
// match: (Zero {t1} [n] p1 store:(Store {t2} (OffPtr [o2] p2) _ mem))
if !(s >= 16) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 48) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 32) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 8) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 24) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
if !(s >= 56) {
break
}
- v.reset(OpCopy)
- v.Type = x.Type
- v.AddArg(x)
+ v.copyOf(x)
return true
}
return false
v.Args = v.argstorage[:0]
}
+// reset is called from most rewrite rules.
+// Allowing it to be inlined increases the size
+// of cmd/compile by almost 10%, and slows it down.
+//go:noinline
func (v *Value) reset(op Op) {
v.Op = op
- if op != OpCopy && notStmtBoundary(op) {
- // Special case for OpCopy because of how it is used in rewrite
- v.Pos = v.Pos.WithNotStmt()
- }
v.resetArgs()
v.AuxInt = 0
v.Aux = nil
}
+// copyOf is called from rewrite rules.
+// It modifies v to be (Copy a).
+//go:noinline
+func (v *Value) copyOf(a *Value) {
+ v.Op = OpCopy
+ v.resetArgs()
+ v.AddArg(a)
+ v.AuxInt = 0
+ v.Aux = nil
+ v.Type = a.Type
+}
+
// copyInto makes a new value identical to v and adds it to the end of b.
// unlike copyIntoWithXPos this does not check for v.Pos being a statement.
func (v *Value) copyInto(b *Block) *Value {
bEnd.Values = append(bEnd.Values, last)
last.Block = bEnd
last.reset(OpPhi)
+ last.Pos = last.Pos.WithNotStmt()
last.Type = types.TypeMem
last.AddArg(memThen)
last.AddArg(memElse)