cmd/compile: optimize loads from readonly globals into constants on loong64

Ref: CL 141118
Update #26498

Change-Id: I9c4ad2bedc4d50bd273bbe9119a898d4fca95e45
Reviewed-on: https://go-review.googlesource.com/c/go/+/700875
Reviewed-by: abner chenc <chenguoqi@loongson.cn>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Meidan Li <limeidan@loongson.cn>
Auto-Submit: Michael Pratt <mpratt@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

diff --git a/src/cmd/compile/internal/ssa/_gen/LOONG64.rules b/src/cmd/compile/internal/ssa/_gen/LOONG64.rules
index 501d3745292c05e030ac07ccc1ac14e8b4b7df2b..a3dd050d14b84387c172b73d1260254b35ae706b 100644 (file)
--- a/src/cmd/compile/internal/ssa/_gen/LOONG64.rules
+++ b/src/cmd/compile/internal/ssa/_gen/LOONG64.rules
@@ -949,3 +949,12 @@
        && isInlinableMemmove(dst, src, sz, config)
        && clobber(call)
        => (Move [sz] dst src mem)
+
+// fold readonly sym load
+(MOVBUload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read8(sym, int64(off)))])
+(MOVHUload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+(MOVWUload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+(MOVVload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read64(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+(MOVBload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(int8(read8(sym, int64(off))))])
+(MOVHload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(int16(read16(sym, int64(off), config.ctxt.Arch.ByteOrder)))])
+(MOVWload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(int32(read32(sym, int64(off), config.ctxt.Arch.ByteOrder)))])

diff --git a/src/cmd/compile/internal/ssa/rewriteLOONG64.go b/src/cmd/compile/internal/ssa/rewriteLOONG64.go
index c49ce31ae43e30c128bd8e21e8a61728a7b9af47..036d70a15fbc53d6bfc88aab13cb47351d67fd5e 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteLOONG64.go
+++ b/src/cmd/compile/internal/ssa/rewriteLOONG64.go
@@ -2422,6 +2422,19 @@ func rewriteValueLOONG64_OpLOONG64MOVBUload(v *Value) bool {
                v.AddArg3(ptr, idx, mem)
                return true
        }
+       // match: (MOVBUload [off] {sym} (SB) _)
+       // cond: symIsRO(sym)
+       // result: (MOVVconst [int64(read8(sym, int64(off)))])
+       for {
+               off := auxIntToInt32(v.AuxInt)
+               sym := auxToSym(v.Aux)
+               if v_0.Op != OpSB || !(symIsRO(sym)) {
+                       break
+               }
+               v.reset(OpLOONG64MOVVconst)
+               v.AuxInt = int64ToAuxInt(int64(read8(sym, int64(off))))
+               return true
+       }
        return false
 }
 func rewriteValueLOONG64_OpLOONG64MOVBUloadidx(v *Value) bool {
@@ -2716,6 +2729,19 @@ func rewriteValueLOONG64_OpLOONG64MOVBload(v *Value) bool {
                v.AddArg3(ptr, idx, mem)
                return true
        }
+       // match: (MOVBload [off] {sym} (SB) _)
+       // cond: symIsRO(sym)
+       // result: (MOVVconst [int64(int8(read8(sym, int64(off))))])
+       for {
+               off := auxIntToInt32(v.AuxInt)
+               sym := auxToSym(v.Aux)
+               if v_0.Op != OpSB || !(symIsRO(sym)) {
+                       break
+               }
+               v.reset(OpLOONG64MOVVconst)
+               v.AuxInt = int64ToAuxInt(int64(int8(read8(sym, int64(off)))))
+               return true
+       }
        return false
 }
 func rewriteValueLOONG64_OpLOONG64MOVBloadidx(v *Value) bool {
@@ -3653,6 +3679,19 @@ func rewriteValueLOONG64_OpLOONG64MOVHUload(v *Value) bool {
                v.AddArg3(ptr, idx, mem)
                return true
        }
+       // match: (MOVHUload [off] {sym} (SB) _)
+       // cond: symIsRO(sym)
+       // result: (MOVVconst [int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+       for {
+               off := auxIntToInt32(v.AuxInt)
+               sym := auxToSym(v.Aux)
+               if v_0.Op != OpSB || !(symIsRO(sym)) {
+                       break
+               }
+               v.reset(OpLOONG64MOVVconst)
+               v.AuxInt = int64ToAuxInt(int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder)))
+               return true
+       }
        return false
 }
 func rewriteValueLOONG64_OpLOONG64MOVHUloadidx(v *Value) bool {
@@ -3909,6 +3948,19 @@ func rewriteValueLOONG64_OpLOONG64MOVHload(v *Value) bool {
                v.AddArg3(ptr, idx, mem)
                return true
        }
+       // match: (MOVHload [off] {sym} (SB) _)
+       // cond: symIsRO(sym)
+       // result: (MOVVconst [int64(int16(read16(sym, int64(off), config.ctxt.Arch.ByteOrder)))])
+       for {
+               off := auxIntToInt32(v.AuxInt)
+               sym := auxToSym(v.Aux)
+               if v_0.Op != OpSB || !(symIsRO(sym)) {
+                       break
+               }
+               v.reset(OpLOONG64MOVVconst)
+               v.AuxInt = int64ToAuxInt(int64(int16(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))))
+               return true
+       }
        return false
 }
 func rewriteValueLOONG64_OpLOONG64MOVHloadidx(v *Value) bool {
@@ -4369,6 +4421,19 @@ func rewriteValueLOONG64_OpLOONG64MOVVload(v *Value) bool {
                v.AddArg3(ptr, idx, mem)
                return true
        }
+       // match: (MOVVload [off] {sym} (SB) _)
+       // cond: symIsRO(sym)
+       // result: (MOVVconst [int64(read64(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+       for {
+               off := auxIntToInt32(v.AuxInt)
+               sym := auxToSym(v.Aux)
+               if v_0.Op != OpSB || !(symIsRO(sym)) {
+                       break
+               }
+               v.reset(OpLOONG64MOVVconst)
+               v.AuxInt = int64ToAuxInt(int64(read64(sym, int64(off), config.ctxt.Arch.ByteOrder)))
+               return true
+       }
        return false
 }
 func rewriteValueLOONG64_OpLOONG64MOVVloadidx(v *Value) bool {
@@ -4694,6 +4759,19 @@ func rewriteValueLOONG64_OpLOONG64MOVWUload(v *Value) bool {
                v.AddArg3(ptr, idx, mem)
                return true
        }
+       // match: (MOVWUload [off] {sym} (SB) _)
+       // cond: symIsRO(sym)
+       // result: (MOVVconst [int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))])
+       for {
+               off := auxIntToInt32(v.AuxInt)
+               sym := auxToSym(v.Aux)
+               if v_0.Op != OpSB || !(symIsRO(sym)) {
+                       break
+               }
+               v.reset(OpLOONG64MOVVconst)
+               v.AuxInt = int64ToAuxInt(int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder)))
+               return true
+       }
        return false
 }
 func rewriteValueLOONG64_OpLOONG64MOVWUloadidx(v *Value) bool {
@@ -4983,6 +5061,19 @@ func rewriteValueLOONG64_OpLOONG64MOVWload(v *Value) bool {
                v.AddArg3(ptr, idx, mem)
                return true
        }
+       // match: (MOVWload [off] {sym} (SB) _)
+       // cond: symIsRO(sym)
+       // result: (MOVVconst [int64(int32(read32(sym, int64(off), config.ctxt.Arch.ByteOrder)))])
+       for {
+               off := auxIntToInt32(v.AuxInt)
+               sym := auxToSym(v.Aux)
+               if v_0.Op != OpSB || !(symIsRO(sym)) {
+                       break
+               }
+               v.reset(OpLOONG64MOVVconst)
+               v.AuxInt = int64ToAuxInt(int64(int32(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))))
+               return true
+       }
        return false
 }
 func rewriteValueLOONG64_OpLOONG64MOVWloadidx(v *Value) bool {

diff --git a/test/codegen/strings.go b/test/codegen/strings.go
index 64dcf4c8428d4c9d0c7c69b80136f2e1a6f1518b..fbcef57cd1a33e1a5056adc94c4e721f5f32585d 100644 (file)
--- a/test/codegen/strings.go
+++ b/test/codegen/strings.go
@@ -39,6 +39,7 @@ func ConstantLoad() {
        //   386:`MOVW\t\$12592, \(`,`MOVB\t\$50, 2\(`
        //   arm:`MOVW\t\$48`,`MOVW\t\$49`,`MOVW\t\$50`
        // arm64:`MOVD\t\$12592`,`MOVD\t\$50`
+       // loong64:`MOVV\t\$12592`,`MOVV\t\$50`
        //  wasm:`I64Const\t\$12592`,`I64Store16\t\$0`,`I64Const\t\$50`,`I64Store8\t\$2`
        // mips64:`MOVV\t\$48`,`MOVV\t\$49`,`MOVV\t\$50`
        bsink = []byte("012")
@@ -48,6 +49,7 @@ func ConstantLoad() {
        // amd64:`MOVL\t\$858927408`,`MOVW\t\$13620, 4\(`
        //   386:`MOVL\t\$858927408`,`MOVW\t\$13620, 4\(`
        // arm64:`MOVD\t\$858927408`,`MOVD\t\$13620`
+       // loong64:`MOVV\t\$858927408`,`MOVV\t\$13620`
        //  wasm:`I64Const\t\$858927408`,`I64Store32\t\$0`,`I64Const\t\$13620`,`I64Store16\t\$4`
        bsink = []byte("012345")
 
@@ -56,19 +58,23 @@ func ConstantLoad() {
        // amd64:`MOVQ\t\$3978425819141910832`,`MOVQ\t\$7306073769690871863`
        //   386:`MOVL\t\$858927408, \(`,`DUFFCOPY`
        // arm64:`MOVD\t\$3978425819141910832`,`MOVD\t\$7306073769690871863`,`MOVD\t\$15`
+       // loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$7306073769690871863`,`MOVV\t\$15`
        //  wasm:`I64Const\t\$3978425819141910832`,`I64Store\t\$0`,`I64Const\t\$7306073769690871863`,`I64Store\t\$7`
        bsink = []byte("0123456789abcde")
 
        // 56 = 0x38
        // amd64:`MOVQ\t\$3978425819141910832`,`MOVB\t\$56`
+       // loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$56`
        bsink = []byte("012345678")
 
        // 14648 = 0x3938
        // amd64:`MOVQ\t\$3978425819141910832`,`MOVW\t\$14648`
+       // loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$14648`
        bsink = []byte("0123456789")
 
        // 1650538808 = 0x62613938
        // amd64:`MOVQ\t\$3978425819141910832`,`MOVL\t\$1650538808`
+       // loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$1650538808`
        bsink = []byte("0123456789ab")
 }