cmd/compile/internal/ssa: eliminate unnecessary extension operations

Reduce the number of go toolchain instructions on loong64 as follows:

	file	     before	after	     Δ 	      %
	go	     1598706	1597230	   -1476    -0.0923%
	gofmt	     325180	324736	   -444     -0.1365%
	asm	     562538	562098	   -440     -0.0782%
	cgo	     488298	487634	   -664     -0.1360%
	compile	     2504502	2503590	   -912     -0.0364%
	cover	     525976	525312	   -664     -0.1262%
	link	     714182	713226	   -956     -0.1339%
	preprofile   241308	240988	   -320     -0.1326%
	vet	     794112	793316	   -796     -0.1002%

Change-Id: I048ef79518b41e83c53da1a3a6b7edaca7cb63f8
Reviewed-on: https://go-review.googlesource.com/c/go/+/693856
Reviewed-by: abner chenc <chenguoqi@loongson.cn>
Reviewed-by: Carlos Amedee <carlos@golang.org>
Auto-Submit: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: sophie zhao <zhaoxiaolin@loongson.cn>

diff --git a/src/cmd/compile/internal/ssa/_gen/LOONG64.rules b/src/cmd/compile/internal/ssa/_gen/LOONG64.rules
index 1b7d4049c64b5fd5b05cdf5b9ce3bb38c50a36c2..bef2b8615b30129527a037107911b93ea438d595 100644 (file)
--- a/src/cmd/compile/internal/ssa/_gen/LOONG64.rules
+++ b/src/cmd/compile/internal/ssa/_gen/LOONG64.rules
@@ -608,6 +608,21 @@
 (MOVWUreg x:(MOVBUload _ _)) => (MOVVreg x)
 (MOVWUreg x:(MOVHUload _ _)) => (MOVVreg x)
 (MOVWUreg x:(MOVWUload _ _)) => (MOVVreg x)
+(MOVBreg x:(MOVBloadidx _ _ _)) => (MOVVreg x)
+(MOVBUreg x:(MOVBUloadidx _ _ _)) => (MOVVreg x)
+(MOVHreg x:(MOVBloadidx _ _ _)) => (MOVVreg x)
+(MOVHreg x:(MOVBUloadidx _ _ _)) => (MOVVreg x)
+(MOVHreg x:(MOVHloadidx _ _ _)) => (MOVVreg x)
+(MOVHUreg x:(MOVBUloadidx _ _ _)) => (MOVVreg x)
+(MOVHUreg x:(MOVHUloadidx _ _ _)) => (MOVVreg x)
+(MOVWreg x:(MOVBloadidx _ _ _)) => (MOVVreg x)
+(MOVWreg x:(MOVBUloadidx _ _ _)) => (MOVVreg x)
+(MOVWreg x:(MOVHloadidx _ _ _)) => (MOVVreg x)
+(MOVWreg x:(MOVHUloadidx _ _ _)) => (MOVVreg x)
+(MOVWreg x:(MOVWloadidx _ _ _)) => (MOVVreg x)
+(MOVWUreg x:(MOVBUloadidx _ _ _)) => (MOVVreg x)
+(MOVWUreg x:(MOVHUloadidx _ _ _)) => (MOVVreg x)
+(MOVWUreg x:(MOVWUloadidx _ _ _)) => (MOVVreg x)
 
 // fold double extensions
 (MOVBreg x:(MOVBreg _)) => (MOVVreg x)

diff --git a/src/cmd/compile/internal/ssa/rewriteLOONG64.go b/src/cmd/compile/internal/ssa/rewriteLOONG64.go
index 8d29912f4071154562a1efa41e3983d46926ac22..c688409657099c52702cebffec2efd4b5140c493 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteLOONG64.go
+++ b/src/cmd/compile/internal/ssa/rewriteLOONG64.go
@@ -2559,6 +2559,17 @@ func rewriteValueLOONG64_OpLOONG64MOVBUreg(v *Value) bool {
                v.AddArg(x)
                return true
        }
+       // match: (MOVBUreg x:(MOVBUloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVBUloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
        // match: (MOVBUreg x:(MOVBUreg _))
        // result: (MOVVreg x)
        for {
@@ -2750,6 +2761,17 @@ func rewriteValueLOONG64_OpLOONG64MOVBreg(v *Value) bool {
                v.AddArg(x)
                return true
        }
+       // match: (MOVBreg x:(MOVBloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVBloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
        // match: (MOVBreg x:(MOVBreg _))
        // result: (MOVVreg x)
        for {
@@ -3827,6 +3849,28 @@ func rewriteValueLOONG64_OpLOONG64MOVHUreg(v *Value) bool {
                v.AddArg(x)
                return true
        }
+       // match: (MOVHUreg x:(MOVBUloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVBUloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
+       // match: (MOVHUreg x:(MOVHUloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVHUloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
        // match: (MOVHUreg x:(MOVBUreg _))
        // result: (MOVVreg x)
        for {
@@ -4038,6 +4082,39 @@ func rewriteValueLOONG64_OpLOONG64MOVHreg(v *Value) bool {
                v.AddArg(x)
                return true
        }
+       // match: (MOVHreg x:(MOVBloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVBloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
+       // match: (MOVHreg x:(MOVBUloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVBUloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
+       // match: (MOVHreg x:(MOVHloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVHloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
        // match: (MOVHreg x:(MOVBreg _))
        // result: (MOVVreg x)
        for {
@@ -5053,6 +5130,39 @@ func rewriteValueLOONG64_OpLOONG64MOVWUreg(v *Value) bool {
                v.AddArg(x)
                return true
        }
+       // match: (MOVWUreg x:(MOVBUloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVBUloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
+       // match: (MOVWUreg x:(MOVHUloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVHUloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
+       // match: (MOVWUreg x:(MOVWUloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVWUloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
        // match: (MOVWUreg x:(MOVBUreg _))
        // result: (MOVVreg x)
        for {
@@ -5297,6 +5407,61 @@ func rewriteValueLOONG64_OpLOONG64MOVWreg(v *Value) bool {
                v.AddArg(x)
                return true
        }
+       // match: (MOVWreg x:(MOVBloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVBloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
+       // match: (MOVWreg x:(MOVBUloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVBUloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
+       // match: (MOVWreg x:(MOVHloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVHloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
+       // match: (MOVWreg x:(MOVHUloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVHUloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
+       // match: (MOVWreg x:(MOVWloadidx _ _ _))
+       // result: (MOVVreg x)
+       for {
+               x := v_0
+               if x.Op != OpLOONG64MOVWloadidx {
+                       break
+               }
+               v.reset(OpLOONG64MOVVreg)
+               v.AddArg(x)
+               return true
+       }
        // match: (MOVWreg x:(MOVBreg _))
        // result: (MOVVreg x)
        for {