cmd/compile: remove folding of 32 bit pointer offsets on amd64

These rules were likely only used in the removed amd64p32 port.

Passes toolstash -cmp.

Change-Id: Ie626d1021bade7f7571d1bd5271fbe8676bb295e
Reviewed-on: https://go-review.googlesource.com/c/go/+/346509
Trust: Martin Möhrmann <martin@golang.org>
Run-TryBot: Martin Möhrmann <martin@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 94fce2d4e5171b9653c1cabd2ce89bc931e9cae3..54ed5f7ad1d2d3b25b184361d4de0ca6608f7a3f 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -2021,54 +2021,6 @@
   && clobber(x1, x2, mem2)
   => (MOVQstore [i-4] {s} p (MOVQload [j-4] {s2} p2 mem) mem)
 
-(MOVQload  [off1] {sym1} (LEAL [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) =>
-       (MOVQload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
-(MOVLload  [off1] {sym1} (LEAL [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) =>
-       (MOVLload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
-(MOVWload  [off1] {sym1} (LEAL [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) =>
-       (MOVWload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
-(MOVBload  [off1] {sym1} (LEAL [off2] {sym2} base) mem) && canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) =>
-       (MOVBload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
-
-(MOVQstore  [off1] {sym1} (LEAL [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) =>
-       (MOVQstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-(MOVLstore  [off1] {sym1} (LEAL [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) =>
-       (MOVLstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-(MOVWstore  [off1] {sym1} (LEAL [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) =>
-       (MOVWstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-(MOVBstore  [off1] {sym1} (LEAL [off2] {sym2} base) val mem) && canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) =>
-       (MOVBstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-
-(MOVOstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && sc.canAdd32(off) =>
-       (MOVOstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-(MOVQstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && sc.canAdd32(off) =>
-       (MOVQstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-(MOVLstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && sc.canAdd32(off) =>
-       (MOVLstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-(MOVWstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && sc.canAdd32(off) =>
-       (MOVWstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-(MOVBstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && sc.canAdd32(off) =>
-       (MOVBstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-
-(MOVQload  [off1] {sym} (ADDLconst [off2] ptr) mem) && is32Bit(int64(off1)+int64(off2)) => (MOVQload  [off1+off2] {sym} ptr mem)
-(MOVLload  [off1] {sym} (ADDLconst [off2] ptr) mem) && is32Bit(int64(off1)+int64(off2)) => (MOVLload  [off1+off2] {sym} ptr mem)
-(MOVWload  [off1] {sym} (ADDLconst [off2] ptr) mem) && is32Bit(int64(off1)+int64(off2)) => (MOVWload  [off1+off2] {sym} ptr mem)
-(MOVBload  [off1] {sym} (ADDLconst [off2] ptr) mem) && is32Bit(int64(off1)+int64(off2)) => (MOVBload  [off1+off2] {sym} ptr mem)
-(MOVQstore  [off1] {sym} (ADDLconst [off2] ptr) val mem) && is32Bit(int64(off1)+int64(off2)) => (MOVQstore  [off1+off2] {sym} ptr val mem)
-(MOVLstore  [off1] {sym} (ADDLconst [off2] ptr) val mem) && is32Bit(int64(off1)+int64(off2)) => (MOVLstore  [off1+off2] {sym} ptr val mem)
-(MOVWstore  [off1] {sym} (ADDLconst [off2] ptr) val mem) && is32Bit(int64(off1)+int64(off2)) => (MOVWstore  [off1+off2] {sym} ptr val mem)
-(MOVBstore  [off1] {sym} (ADDLconst [off2] ptr) val mem) && is32Bit(int64(off1)+int64(off2)) => (MOVBstore  [off1+off2] {sym} ptr val mem)
-(MOVQstoreconst [sc] {s} (ADDLconst [off] ptr) mem) && sc.canAdd32(off) =>
-       (MOVQstoreconst [sc.addOffset32(off)] {s} ptr mem)
-(MOVLstoreconst [sc] {s} (ADDLconst [off] ptr) mem) && sc.canAdd32(off) =>
-       (MOVLstoreconst [sc.addOffset32(off)] {s} ptr mem)
-(MOVWstoreconst [sc] {s} (ADDLconst [off] ptr) mem) && sc.canAdd32(off) =>
-       (MOVWstoreconst [sc.addOffset32(off)] {s} ptr mem)
-(MOVBstoreconst [sc] {s} (ADDLconst [off] ptr) mem) && sc.canAdd32(off) =>
-       (MOVBstoreconst [sc.addOffset32(off)] {s} ptr mem)
-(MOVOstoreconst [sc] {s} (ADDLconst [off] ptr) mem) && sc.canAdd32(off) =>
-       (MOVOstoreconst [sc.addOffset32(off)] {s} ptr mem)
-
 // Merge load and op
 // TODO: add indexed variants?
 ((ADD|SUB|AND|OR|XOR)Q x l:(MOVQload [off] {sym} ptr mem)) && canMergeLoadClobber(v, l, x) && clobber(l) => ((ADD|SUB|AND|OR|XOR)Qload x [off] {sym} ptr mem)

diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 2aa3786a7e650ed3c66757ecd7d3f36e1ad4adb4..1db16318c80918ea875f498fb30ed8c66ef81937 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -9632,49 +9632,6 @@ func rewriteValueAMD64_OpAMD64MOVBload(v *Value) bool {
                v.AddArg2(base, mem)
                return true
        }
-       // match: (MOVBload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
-       // cond: canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))
-       // result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} base mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               base := v_0.Args[0]
-               mem := v_1
-               if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVBload)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg2(base, mem)
-               return true
-       }
-       // match: (MOVBload [off1] {sym} (ADDLconst [off2] ptr) mem)
-       // cond: is32Bit(int64(off1)+int64(off2))
-       // result: (MOVBload [off1+off2] {sym} ptr mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(is32Bit(int64(off1) + int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVBload)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(sym)
-               v.AddArg2(ptr, mem)
-               return true
-       }
        // match: (MOVBload [off] {sym} (SB) _)
        // cond: symIsRO(sym)
        // result: (MOVLconst [int32(read8(sym, int64(off)))])
@@ -10879,51 +10836,6 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
                v.AddArg3(p, v0, mem)
                return true
        }
-       // match: (MOVBstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
-       // cond: canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))
-       // result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               base := v_0.Args[0]
-               val := v_1
-               mem := v_2
-               if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVBstore)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg3(base, val, mem)
-               return true
-       }
-       // match: (MOVBstore [off1] {sym} (ADDLconst [off2] ptr) val mem)
-       // cond: is32Bit(int64(off1)+int64(off2))
-       // result: (MOVBstore [off1+off2] {sym} ptr val mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               val := v_1
-               mem := v_2
-               if !(is32Bit(int64(off1) + int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVBstore)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(sym)
-               v.AddArg3(ptr, val, mem)
-               return true
-       }
        return false
 }
 func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool {
@@ -11022,49 +10934,6 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool {
                v.AddArg2(p, mem)
                return true
        }
-       // match: (MOVBstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
-       // cond: canMergeSym(sym1, sym2) && sc.canAdd32(off)
-       // result: (MOVBstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(canMergeSym(sym1, sym2) && sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVBstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg2(ptr, mem)
-               return true
-       }
-       // match: (MOVBstoreconst [sc] {s} (ADDLconst [off] ptr) mem)
-       // cond: sc.canAdd32(off)
-       // result: (MOVBstoreconst [sc.addOffset32(off)] {s} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               s := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVBstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(s)
-               v.AddArg2(ptr, mem)
-               return true
-       }
        return false
 }
 func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value) bool {
@@ -11493,49 +11362,6 @@ func rewriteValueAMD64_OpAMD64MOVLload(v *Value) bool {
                v.AddArg2(base, mem)
                return true
        }
-       // match: (MOVLload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
-       // cond: canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))
-       // result: (MOVLload [off1+off2] {mergeSym(sym1,sym2)} base mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               base := v_0.Args[0]
-               mem := v_1
-               if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVLload)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg2(base, mem)
-               return true
-       }
-       // match: (MOVLload [off1] {sym} (ADDLconst [off2] ptr) mem)
-       // cond: is32Bit(int64(off1)+int64(off2))
-       // result: (MOVLload [off1+off2] {sym} ptr mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(is32Bit(int64(off1) + int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVLload)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(sym)
-               v.AddArg2(ptr, mem)
-               return true
-       }
        // match: (MOVLload [off] {sym} ptr (MOVSSstore [off] {sym} ptr val _))
        // result: (MOVLf2i val)
        for {
@@ -11837,51 +11663,6 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
                v.AddArg3(p, v0, mem)
                return true
        }
-       // match: (MOVLstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
-       // cond: canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))
-       // result: (MOVLstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               base := v_0.Args[0]
-               val := v_1
-               mem := v_2
-               if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVLstore)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg3(base, val, mem)
-               return true
-       }
-       // match: (MOVLstore [off1] {sym} (ADDLconst [off2] ptr) val mem)
-       // cond: is32Bit(int64(off1)+int64(off2))
-       // result: (MOVLstore [off1+off2] {sym} ptr val mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               val := v_1
-               mem := v_2
-               if !(is32Bit(int64(off1) + int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVLstore)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(sym)
-               v.AddArg3(ptr, val, mem)
-               return true
-       }
        // match: (MOVLstore {sym} [off] ptr y:(ADDLload x [off] {sym} ptr mem) mem)
        // cond: y.Uses==1 && clobber(y)
        // result: (ADDLmodify [off] {sym} ptr x mem)
@@ -12365,49 +12146,6 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
                v.AddArg3(p, v0, mem)
                return true
        }
-       // match: (MOVLstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
-       // cond: canMergeSym(sym1, sym2) && sc.canAdd32(off)
-       // result: (MOVLstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(canMergeSym(sym1, sym2) && sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVLstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg2(ptr, mem)
-               return true
-       }
-       // match: (MOVLstoreconst [sc] {s} (ADDLconst [off] ptr) mem)
-       // cond: sc.canAdd32(off)
-       // result: (MOVLstoreconst [sc.addOffset32(off)] {s} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               s := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVLstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(s)
-               v.AddArg2(ptr, mem)
-               return true
-       }
        return false
 }
 func rewriteValueAMD64_OpAMD64MOVOload(v *Value) bool {
@@ -12592,49 +12330,6 @@ func rewriteValueAMD64_OpAMD64MOVOstoreconst(v *Value) bool {
                v.AddArg2(ptr, mem)
                return true
        }
-       // match: (MOVOstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
-       // cond: canMergeSym(sym1, sym2) && sc.canAdd32(off)
-       // result: (MOVOstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(canMergeSym(sym1, sym2) && sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVOstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg2(ptr, mem)
-               return true
-       }
-       // match: (MOVOstoreconst [sc] {s} (ADDLconst [off] ptr) mem)
-       // cond: sc.canAdd32(off)
-       // result: (MOVOstoreconst [sc.addOffset32(off)] {s} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               s := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVOstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(s)
-               v.AddArg2(ptr, mem)
-               return true
-       }
        return false
 }
 func rewriteValueAMD64_OpAMD64MOVQatomicload(v *Value) bool {
@@ -12805,49 +12500,6 @@ func rewriteValueAMD64_OpAMD64MOVQload(v *Value) bool {
                v.AddArg2(base, mem)
                return true
        }
-       // match: (MOVQload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
-       // cond: canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))
-       // result: (MOVQload [off1+off2] {mergeSym(sym1,sym2)} base mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               base := v_0.Args[0]
-               mem := v_1
-               if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVQload)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg2(base, mem)
-               return true
-       }
-       // match: (MOVQload [off1] {sym} (ADDLconst [off2] ptr) mem)
-       // cond: is32Bit(int64(off1)+int64(off2))
-       // result: (MOVQload [off1+off2] {sym} ptr mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(is32Bit(int64(off1) + int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVQload)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(sym)
-               v.AddArg2(ptr, mem)
-               return true
-       }
        // match: (MOVQload [off] {sym} ptr (MOVSDstore [off] {sym} ptr val _))
        // result: (MOVQf2i val)
        for {
@@ -12950,51 +12602,6 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
                v.AddArg3(base, val, mem)
                return true
        }
-       // match: (MOVQstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
-       // cond: canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))
-       // result: (MOVQstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               base := v_0.Args[0]
-               val := v_1
-               mem := v_2
-               if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVQstore)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg3(base, val, mem)
-               return true
-       }
-       // match: (MOVQstore [off1] {sym} (ADDLconst [off2] ptr) val mem)
-       // cond: is32Bit(int64(off1)+int64(off2))
-       // result: (MOVQstore [off1+off2] {sym} ptr val mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               val := v_1
-               mem := v_2
-               if !(is32Bit(int64(off1) + int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVQstore)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(sym)
-               v.AddArg3(ptr, val, mem)
-               return true
-       }
        // match: (MOVQstore {sym} [off] ptr y:(ADDQload x [off] {sym} ptr mem) mem)
        // cond: y.Uses==1 && clobber(y)
        // result: (ADDQmodify [off] {sym} ptr x mem)
@@ -13474,49 +13081,6 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
                v.AddArg2(p, mem)
                return true
        }
-       // match: (MOVQstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
-       // cond: canMergeSym(sym1, sym2) && sc.canAdd32(off)
-       // result: (MOVQstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(canMergeSym(sym1, sym2) && sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVQstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg2(ptr, mem)
-               return true
-       }
-       // match: (MOVQstoreconst [sc] {s} (ADDLconst [off] ptr) mem)
-       // cond: sc.canAdd32(off)
-       // result: (MOVQstoreconst [sc.addOffset32(off)] {s} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               s := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVQstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(s)
-               v.AddArg2(ptr, mem)
-               return true
-       }
        return false
 }
 func rewriteValueAMD64_OpAMD64MOVSDload(v *Value) bool {
@@ -14135,49 +13699,6 @@ func rewriteValueAMD64_OpAMD64MOVWload(v *Value) bool {
                v.AddArg2(base, mem)
                return true
        }
-       // match: (MOVWload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
-       // cond: canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))
-       // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} base mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               base := v_0.Args[0]
-               mem := v_1
-               if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVWload)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg2(base, mem)
-               return true
-       }
-       // match: (MOVWload [off1] {sym} (ADDLconst [off2] ptr) mem)
-       // cond: is32Bit(int64(off1)+int64(off2))
-       // result: (MOVWload [off1+off2] {sym} ptr mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(is32Bit(int64(off1) + int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVWload)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(sym)
-               v.AddArg2(ptr, mem)
-               return true
-       }
        // match: (MOVWload [off] {sym} (SB) _)
        // cond: symIsRO(sym)
        // result: (MOVLconst [int32(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
@@ -14571,51 +14092,6 @@ func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool {
                v.AddArg3(p, v0, mem)
                return true
        }
-       // match: (MOVWstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
-       // cond: canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))
-       // result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               base := v_0.Args[0]
-               val := v_1
-               mem := v_2
-               if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVWstore)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg3(base, val, mem)
-               return true
-       }
-       // match: (MOVWstore [off1] {sym} (ADDLconst [off2] ptr) val mem)
-       // cond: is32Bit(int64(off1)+int64(off2))
-       // result: (MOVWstore [off1+off2] {sym} ptr val mem)
-       for {
-               off1 := auxIntToInt32(v.AuxInt)
-               sym := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off2 := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               val := v_1
-               mem := v_2
-               if !(is32Bit(int64(off1) + int64(off2))) {
-                       break
-               }
-               v.reset(OpAMD64MOVWstore)
-               v.AuxInt = int32ToAuxInt(off1 + off2)
-               v.Aux = symToAux(sym)
-               v.AddArg3(ptr, val, mem)
-               return true
-       }
        return false
 }
 func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool {
@@ -14714,49 +14190,6 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool {
                v.AddArg2(p, mem)
                return true
        }
-       // match: (MOVWstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
-       // cond: canMergeSym(sym1, sym2) && sc.canAdd32(off)
-       // result: (MOVWstoreconst [sc.addOffset32(off)] {mergeSym(sym1, sym2)} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               sym1 := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64LEAL {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               sym2 := auxToSym(v_0.Aux)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(canMergeSym(sym1, sym2) && sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVWstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(mergeSym(sym1, sym2))
-               v.AddArg2(ptr, mem)
-               return true
-       }
-       // match: (MOVWstoreconst [sc] {s} (ADDLconst [off] ptr) mem)
-       // cond: sc.canAdd32(off)
-       // result: (MOVWstoreconst [sc.addOffset32(off)] {s} ptr mem)
-       for {
-               sc := auxIntToValAndOff(v.AuxInt)
-               s := auxToSym(v.Aux)
-               if v_0.Op != OpAMD64ADDLconst {
-                       break
-               }
-               off := auxIntToInt32(v_0.AuxInt)
-               ptr := v_0.Args[0]
-               mem := v_1
-               if !(sc.canAdd32(off)) {
-                       break
-               }
-               v.reset(OpAMD64MOVWstoreconst)
-               v.AuxInt = valAndOffToAuxInt(sc.addOffset32(off))
-               v.Aux = symToAux(s)
-               v.AddArg2(ptr, mem)
-               return true
-       }
        return false
 }
 func rewriteValueAMD64_OpAMD64MULL(v *Value) bool {