[release-branch.go1.20] cmd/compile: wire up Bswap/ReverseBytes intri…

…nsics for loong64

Micro-benchmark results on Loongson 3A5000:

goos: linux
goarch: loong64
pkg: math/bits
               │    before    │                after                 │
               │    sec/op    │    sec/op     vs base                │
ReverseBytes     3.0130n ± 0%   0.6517n ± 2%  -78.37% (p=0.000 n=10)
ReverseBytes16   0.9027n ± 0%   0.6526n ± 2%  -27.71% (p=0.000 n=10)
ReverseBytes32   1.7040n ± 0%   0.6511n ± 1%  -61.79% (p=0.000 n=10)
ReverseBytes64   2.7080n ± 0%   0.6499n ± 1%  -76.00% (p=0.000 n=10)
geomean           1.882n        0.6513n       -65.40%

Go1 benchmark results indicate no meaningful change except for
micro-architecture-related fluctuations.

Updates golang#59120

Change-Id: I39c1edbd7363f454ad1e848a25abeced722b16ac
(cherry picked from commit 4e0bacc50e09ea7defbf1e769b6ee5467e82e881)

src/cmd/compile/internal/loong64/ssa.go

@@ -352,6 +352,9 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpLOONG64CTZV,
 		ssa.OpLOONG64CLZW,
 		ssa.OpLOONG64CLZV,
+		ssa.OpLOONG64REVB2H,
+		ssa.OpLOONG64REVB2W,
+		ssa.OpLOONG64REVBV,
 		ssa.OpLOONG64SQRTD,
 		ssa.OpLOONG64SQRTF:
 		p := s.Prog(v.Op.Asm())

src/cmd/compile/internal/ssa/_gen/LOONG64.rules

@@ -133,6 +133,7 @@
 (Ctz(32|64) ...) => (CTZ(W|V) ...)
 (BitLen64 <t> x) => (NEGV <t> (SUBVconst <t> [64] (CLZV <t> x)))
 (BitLen32 <t> x) => (NEGV <t> (SUBVconst <t> [32] (CLZW <t> x)))
+(Bswap(16|32|64) ...) => (REVB(2H|2W|V) ...)
 
 (Sqrt ...) => (SQRTD ...)
 (Sqrt32 ...) => (SQRTF ...)

src/cmd/compile/internal/ssa/_gen/LOONG64Ops.go

@@ -197,15 +197,18 @@ func init() {
 		{name: "FNMSUBF", argLength: 3, reg: fp31, asm: "FNMSUBF", commutative: true, typ: "Float32"}, // -((arg0 * arg1) - arg2)
 		{name: "FNMSUBD", argLength: 3, reg: fp31, asm: "FNMSUBD", commutative: true, typ: "Float64"}, // -((arg0 * arg1) - arg2)
 
-		{name: "NEGV", argLength: 1, reg: gp11},                // -arg0
-		{name: "NEGF", argLength: 1, reg: fp11, asm: "NEGF"},   // -arg0, float32
-		{name: "NEGD", argLength: 1, reg: fp11, asm: "NEGD"},   // -arg0, float64
-		{name: "SQRTD", argLength: 1, reg: fp11, asm: "SQRTD"}, // sqrt(arg0), float64
-		{name: "SQRTF", argLength: 1, reg: fp11, asm: "SQRTF"}, // sqrt(arg0), float32
-		{name: "CTZW", argLength: 1, reg: gp11, asm: "CTZW"},   // Count trailing (low order) zeroes (returns 0-32)
-		{name: "CTZV", argLength: 1, reg: gp11, asm: "CTZV"},   // Count trailing (low order) zeroes (returns 0-64)
-		{name: "CLZW", argLength: 1, reg: gp11, asm: "CLZW"},   // Count leading (high order) zeroes (returns 0-32)
-		{name: "CLZV", argLength: 1, reg: gp11, asm: "CLZV"},   // Count leading (high order) zeroes (returns 0-64)
+		{name: "NEGV", argLength: 1, reg: gp11},                  // -arg0
+		{name: "NEGF", argLength: 1, reg: fp11, asm: "NEGF"},     // -arg0, float32
+		{name: "NEGD", argLength: 1, reg: fp11, asm: "NEGD"},     // -arg0, float64
+		{name: "SQRTD", argLength: 1, reg: fp11, asm: "SQRTD"},   // sqrt(arg0), float64
+		{name: "SQRTF", argLength: 1, reg: fp11, asm: "SQRTF"},   // sqrt(arg0), float32
+		{name: "CTZW", argLength: 1, reg: gp11, asm: "CTZW"},     // Count trailing (low order) zeroes (returns 0-32)
+		{name: "CTZV", argLength: 1, reg: gp11, asm: "CTZV"},     // Count trailing (low order) zeroes (returns 0-64)
+		{name: "CLZW", argLength: 1, reg: gp11, asm: "CLZW"},     // Count leading (high order) zeroes (returns 0-32)
+		{name: "CLZV", argLength: 1, reg: gp11, asm: "CLZV"},     // Count leading (high order) zeroes (returns 0-64)
+		{name: "REVB2H", argLength: 1, reg: gp11, asm: "REVB2H"}, // Swap bytes: 0x11223344 -> 0x22114433 (sign extends to 64 bits)
+		{name: "REVB2W", argLength: 1, reg: gp11, asm: "REVB2W"}, // Swap bytes: 0x1122334455667788 -> 0x4433221188776655
+		{name: "REVBV", argLength: 1, reg: gp11, asm: "REVBV"},   // Swap bytes: 0x1122334455667788 -> 0x8877665544332211
 
 		{name: "MASKEQZ", argLength: 2, reg: gp21, asm: "MASKEQZ"}, // returns 0 if arg1 == 0, otherwise returns arg0
 		{name: "MASKNEZ", argLength: 2, reg: gp21, asm: "MASKNEZ"}, // returns 0 if arg1 != 0, otherwise returns arg0

src/cmd/compile/internal/ssagen/ssa.go

@@ -4008,12 +4008,12 @@ func InitTables() {
 		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBswap32, types.Types[types.TUINT32], args[0])
 		},
-		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
+		sys.AMD64, sys.ARM64, sys.ARM, sys.Loong64, sys.S390X)
 	addF("runtime/internal/sys", "Bswap64",
 		func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
 			return s.newValue1(ssa.OpBswap64, types.Types[types.TUINT64], args[0])
 		},
-		sys.AMD64, sys.ARM64, sys.ARM, sys.S390X)
+		sys.AMD64, sys.ARM64, sys.ARM, sys.Loong64, sys.S390X)
 
 	/****** Prefetch ******/
 	makePrefetchFunc := func(op ssa.Op) func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {

test/codegen/mathbits.go

@@ -223,20 +223,23 @@ func ReverseBytes(n uint) uint {
 	// amd64:"BSWAPQ"
 	// s390x:"MOVDBR"
 	// arm64:"REV"
+	// loong64:"REVBV"
 	return bits.ReverseBytes(n)
 }
 
 func ReverseBytes64(n uint64) uint64 {
 	// amd64:"BSWAPQ"
 	// s390x:"MOVDBR"
 	// arm64:"REV"
+	// loong64:"REVBV"
 	return bits.ReverseBytes64(n)
 }
 
 func ReverseBytes32(n uint32) uint32 {
 	// amd64:"BSWAPL"
 	// s390x:"MOVWBR"
 	// arm64:"REVW"
+	// loong64:"REVB2W"
 	return bits.ReverseBytes32(n)
 }
 
@@ -246,6 +249,7 @@ func ReverseBytes16(n uint16) uint16 {
 	// arm/5:"SLL","SRL","ORR"
 	// arm/6:"REV16"
 	// arm/7:"REV16"
+	// loong64:"REVB2H"
 	return bits.ReverseBytes16(n)
 }