test/codegen: codify bit related code generation for loong64

Change-Id: Ibaee223894693ac4e2694bd1748f57a3e76c0b12
Reviewed-on: https://go-review.googlesource.com/c/go/+/735980
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: abner chenc <chenguoqi@loongson.cn>
Reviewed-by: Michael Pratt <mpratt@google.com>

diff --git a/test/codegen/bits.go b/test/codegen/bits.go
index 98489e321197d0f3c84cd15eeb029c22d8c30df4..b85683ae5fea6f29f246f930cd1619d52ecf03e7 100644 (file)
--- a/test/codegen/bits.go
+++ b/test/codegen/bits.go
@@ -15,18 +15,21 @@ import "math/bits"
 func bitsCheckConstLeftShiftU64(a uint64) (n int) {
        // amd64:"BTQ [$]63,"
        // arm64:"TBNZ [$]63,"
+       // loong64:"MOVV [$]" "AND" "BNE"
        // riscv64:"MOV [$]" "AND" "BNEZ"
        if a&(1<<63) != 0 {
                return 1
        }
        // amd64:"BTQ [$]60,"
        // arm64:"TBNZ [$]60,"
+       // loong64:"MOVV [$]" "AND" "BNE"
        // riscv64:"MOV [$]" "AND" "BNEZ"
        if a&(1<<60) != 0 {
                return 1
        }
        // amd64:"BTL [$]0,"
        // arm64:"TBZ [$]0,"
+       // loong64:"AND [$]1," "BEQ"
        // riscv64:"ANDI" "BEQZ"
        if a&(1<<0) != 0 {
                return 1
@@ -37,42 +40,49 @@ func bitsCheckConstLeftShiftU64(a uint64) (n int) {
 func bitsCheckConstRightShiftU64(a [8]uint64) (n int) {
        // amd64:"BTQ [$]63,"
        // arm64:"LSR [$]63," "TBNZ [$]0,"
+       // loong64:"SRLV [$]63," "AND [$]1," "BNE"
        // riscv64:"SRLI" "ANDI" "BNEZ"
        if (a[0]>>63)&1 != 0 {
                return 1
        }
        // amd64:"BTQ [$]63,"
        // arm64:"LSR [$]63," "CBNZ"
+       // loong64:"SRLV [$]63," "BNE"
        // riscv64:"SRLI" "BNEZ"
        if a[1]>>63 != 0 {
                return 1
        }
        // amd64:"BTQ [$]63,"
        // arm64:"LSR [$]63," "CBZ"
+       // loong64:"SRLV [$]63," "BEQ"
        // riscv64:"SRLI" "BEQZ"
        if a[2]>>63 == 0 {
                return 1
        }
        // amd64:"BTQ [$]60,"
        // arm64:"LSR [$]60," "TBZ [$]0,"
+       // loong64:"SRLV [$]60," "AND [$]1," "BEQ"
        // riscv64:"SRLI", "ANDI" "BEQZ"
        if (a[3]>>60)&1 == 0 {
                return 1
        }
        // amd64:"BTL [$]1,"
        // arm64:"LSR [$]1," "TBZ [$]0,"
+       // loong64:"SRLV [$]1," "AND [$]1," "BEQ"
        // riscv64:"SRLI" "ANDI" "BEQZ"
        if (a[4]>>1)&1 == 0 {
                return 1
        }
        // amd64:"BTL [$]0,"
        // arm64:"TBZ [$]0," -"LSR"
+       // loong64:"AND [$]1," "BEQ" -"SRLV"
        // riscv64:"ANDI" "BEQZ" -"SRLI"
        if (a[5]>>0)&1 == 0 {
                return 1
        }
        // amd64:"BTL [$]7,"
        // arm64:"LSR [$]5," "TBNZ [$]2,"
+       // loong64:"SRLV [$]5," "AND [$]4," "BNE"
        // riscv64:"SRLI" "ANDI" "BNEZ"
        if (a[6]>>5)&4 == 0 {
                return 1
@@ -83,12 +93,14 @@ func bitsCheckConstRightShiftU64(a [8]uint64) (n int) {
 func bitsCheckVarU64(a, b uint64) (n int) {
        // amd64:"BTQ"
        // arm64:"MOVD [$]1," "LSL" "TST"
+       // loong64:"MOVV [$]1," "SLLV R" "AND" "BNE"
        // riscv64:"ANDI [$]63," "SLL " "AND "
        if a&(1<<(b&63)) != 0 {
                return 1
        }
        // amd64:"BTQ" -"BT. [$]0,"
        // arm64:"LSR" "TBZ [$]0,"
+       // loong64:"SRLV" "AND [$]1," "BEQ"
        // riscv64:"ANDI [$]63," "SRL" "ANDI [$]1,"
        if (b>>(a&63))&1 != 0 {
                return 1
@@ -99,18 +111,21 @@ func bitsCheckVarU64(a, b uint64) (n int) {
 func bitsCheckMaskU64(a uint64) (n int) {
        // amd64:"BTQ [$]63,"
        // arm64:"TBNZ [$]63,"
+       // loong64:"MOVV [$]" "AND" "BNE"
        // riscv64:"MOV [$]" "AND" "BNEZ"
        if a&0x8000000000000000 != 0 {
                return 1
        }
        // amd64:"BTQ [$]59,"
        // arm64:"TBNZ [$]59,"
+       // loong64:"MOVV [$]" "AND" "BNE"
        // riscv64:"MOV [$]" "AND" "BNEZ"
        if a&0x800000000000000 != 0 {
                return 1
        }
        // amd64:"BTL [$]0,"
        // arm64:"TBZ [$]0,"
+       // loong64:"AND [$]1," "BEQ"
        // riscv64:"ANDI" "BEQZ"
        if a&0x1 != 0 {
                return 1
@@ -121,21 +136,25 @@ func bitsCheckMaskU64(a uint64) (n int) {
 func bitsSetU64(a, b uint64) (n uint64) {
        // amd64:"BTSQ"
        // arm64:"MOVD [$]1," "LSL" "ORR"
+       // loong64:"MOVV [$]1," "SLLV" "OR"
        // riscv64:"ANDI" "SLL" "OR"
        n += b | (1 << (a & 63))
 
        // amd64:"BTSQ [$]63,"
        // arm64:"ORR [$]-9223372036854775808,"
+       // loong64:"MOVV [$]" "OR"
        // riscv64:"MOV [$]" "OR "
        n += a | (1 << 63)
 
        // amd64:"BTSQ [$]60,"
        // arm64:"ORR [$]1152921504606846976,"
+       // loong64:"MOVV [$]" "OR"
        // riscv64:"MOV [$]" "OR "
        n += a | (1 << 60)
 
        // amd64:"ORQ [$]1,"
        // arm64:"ORR [$]1,"
+       // loong64:"OR [$]1,"
        // riscv64:"ORI"
        n += a | (1 << 0)
 
@@ -145,21 +164,25 @@ func bitsSetU64(a, b uint64) (n uint64) {
 func bitsClearU64(a, b uint64) (n uint64) {
        // amd64:"BTRQ"
        // arm64:"MOVD [$]1," "LSL" "BIC"
+       // loong64:"MOVV [$]1," "SLLV" "ANDN"
        // riscv64:"ANDI" "SLL" "ANDN"
        n += b &^ (1 << (a & 63))
 
        // amd64:"BTRQ [$]63,"
        // arm64:"AND [$]9223372036854775807,"
+       // loong64:"MOVV [$]" "AND "
        // riscv64:"MOV [$]" "AND "
        n += a &^ (1 << 63)
 
        // amd64:"BTRQ [$]60,"
        // arm64:"AND [$]-1152921504606846977,"
+       // loong64:"MOVV [$]" "AND "
        // riscv64:"MOV [$]" "AND "
        n += a &^ (1 << 60)
 
        // amd64:"ANDQ [$]-2"
        // arm64:"AND [$]-2"
+       // loong64:"AND [$]-2"
        // riscv64:"ANDI [$]-2"
        n += a &^ (1 << 0)
 
@@ -169,11 +192,13 @@ func bitsClearU64(a, b uint64) (n uint64) {
 func bitsClearLowest(x int64, y int32) (int64, int32) {
        // amd64:"ANDQ [$]-2,"
        // arm64:"AND [$]-2,"
+       // loong64:"AND [$]-2,"
        // riscv64:"ANDI [$]-2,"
        a := (x >> 1) << 1
 
        // amd64:"ANDL [$]-2,"
        // arm64:"AND [$]-2,"
+       // loong64:"AND [$]-2,"
        // riscv64:"ANDI [$]-2,"
        b := (y >> 1) << 1
 
@@ -183,21 +208,25 @@ func bitsClearLowest(x int64, y int32) (int64, int32) {
 func bitsFlipU64(a, b uint64) (n uint64) {
        // amd64:"BTCQ"
        // arm64:"MOVD [$]1," "LSL" "EOR"
+       // loong64:"MOVV [$]1," "SLLV" "XOR"
        // riscv64:"ANDI" "SLL" "XOR "
        n += b ^ (1 << (a & 63))
 
        // amd64:"BTCQ [$]63,"
        // arm64:"EOR [$]-9223372036854775808,"
+       // loong64:"MOVV [$]" "XOR"
        // riscv64:"MOV [$]" "XOR "
        n += a ^ (1 << 63)
 
        // amd64:"BTCQ [$]60,"
        // arm64:"EOR [$]1152921504606846976,"
+       // loong64:"MOVV [$]" "XOR"
        // riscv64:"MOV [$]" "XOR "
        n += a ^ (1 << 60)
 
        // amd64:"XORQ [$]1,"
        // arm64:"EOR [$]1,"
+       // loong64:"XOR [$]1,"
        // riscv64:"XORI [$]1,"
        n += a ^ (1 << 0)
 
@@ -211,18 +240,21 @@ func bitsFlipU64(a, b uint64) (n uint64) {
 func bitsCheckConstShiftLeftU32(a uint32) (n int) {
        // amd64:"BTL [$]31,"
        // arm64:"TBNZ [$]31,"
+       // loong64:"AND [$]" "MOVWU" "BNE"
        // riscv64:"MOV [$]" "AND" "BNEZ"
        if a&(1<<31) != 0 {
                return 1
        }
        // amd64:"BTL [$]28,"
        // arm64:"TBNZ [$]28,"
+       // loong64:"AND [$]" "BNE"
        // riscv64:"ANDI" "BNEZ"
        if a&(1<<28) != 0 {
                return 1
        }
        // amd64:"BTL [$]0,"
        // arm64:"TBZ [$]0,"
+       // loong64:"AND [$]" "BEQ"
        // riscv64:"ANDI" "BEQZ"
        if a&(1<<0) != 0 {
                return 1
@@ -233,42 +265,49 @@ func bitsCheckConstShiftLeftU32(a uint32) (n int) {
 func bitsCheckConstRightShiftU32(a [8]uint32) (n int) {
        // amd64:"BTL [$]31,"
        // arm64:"UBFX [$]31," "CBNZW"
+       // loong64:"SRL [$]31," "AND [$]1," "BNE"
        // riscv64:"SRLI" "ANDI" "BNEZ"
        if (a[0]>>31)&1 != 0 {
                return 1
        }
        // amd64:"BTL [$]31,"
        // arm64:"UBFX [$]31," "CBNZW"
+       // loong64:"SRL [$]31," "MOVWU" "BNE"
        // riscv64:"SRLI" "BNEZ"
        if a[1]>>31 != 0 {
                return 1
        }
        // amd64:"BTL [$]31,"
        // arm64:"UBFX [$]31," "CBZW"
+       // loong64:"SRL [$]31," "MOVWU" "BEQ"
        // riscv64:"SRLI" "BEQZ"
        if a[2]>>31 == 0 {
                return 1
        }
        // amd64:"BTL [$]28,"
        // arm64:"UBFX [$]28," "TBZ"
+       // loong64:"SRL [$]28," "AND [$]1," "BEQ"
        // riscv64:"SRLI" "ANDI" "BEQZ"
        if (a[3]>>28)&1 == 0 {
                return 1
        }
        // amd64:"BTL [$]1,"
        // arm64:"UBFX [$]1," "TBZ"
+       // loong64:"SRL [$]1," "AND [$]1," "BEQ"
        // riscv64:"SRLI" "ANDI" "BEQZ"
        if (a[4]>>1)&1 == 0 {
                return 1
        }
        // amd64:"BTL [$]0,"
        // arm64:"TBZ" -"UBFX" -"SRL"
+       // loong64:"AND [$]1," "BEQ" -"SRL [$]"
        // riscv64:"ANDI" "BEQZ" -"SRLI "
        if (a[5]>>0)&1 == 0 {
                return 1
        }
        // amd64:"BTL [$]7,"
        // arm64:"UBFX [$]5," "TBNZ"
+       // loong64:"SRL [$]5," "AND [$]4," "BNE"
        // riscv64:"SRLI" "ANDI" "BNEZ"
        if (a[6]>>5)&4 == 0 {
                return 1
@@ -279,12 +318,14 @@ func bitsCheckConstRightShiftU32(a [8]uint32) (n int) {
 func bitsCheckVarU32(a, b uint32) (n int) {
        // amd64:"BTL"
        // arm64:"AND [$]31," "MOVD [$]1," "LSL" "TSTW"
+       // loong64:"MOVV [$]1," "SLL R" "AND R" "MOVWU" "BNE"
        // riscv64:"ANDI [$]31," "SLL " "AND "
        if a&(1<<(b&31)) != 0 {
                return 1
        }
        // amd64:"BTL" -"BT. [$]0"
        // arm64:"AND [$]31," "LSR" "TBZ"
+       // loong64:"SRL R" "AND [$]1," "BEQ"
        // riscv64:"ANDI [$]31," "SRLW " "ANDI [$]1,"
        if (b>>(a&31))&1 != 0 {
                return 1
@@ -295,18 +336,21 @@ func bitsCheckVarU32(a, b uint32) (n int) {
 func bitsCheckMaskU32(a uint32) (n int) {
        // amd64:"BTL [$]31,"
        // arm64:"TBNZ [$]31,"
+       // loong64:"AND [$]" "MOVWU" "BNE"
        // riscv64:"MOV [$]" "AND" "BNEZ"
        if a&0x80000000 != 0 {
                return 1
        }
        // amd64:"BTL [$]27,"
        // arm64:"TBNZ [$]27,"
+       // loong64:"AND [$]" "BNE"
        // riscv64:"ANDI" "BNEZ"
        if a&0x8000000 != 0 {
                return 1
        }
        // amd64:"BTL [$]0,"
        // arm64:"TBZ [$]0,"
+       // loong64:"AND [$]1," "BEQ"
        // riscv64:"ANDI" "BEQZ"
        if a&0x1 != 0 {
                return 1
@@ -317,21 +361,25 @@ func bitsCheckMaskU32(a uint32) (n int) {
 func bitsSetU32(a, b uint32) (n uint32) {
        // amd64:"BTSL"
        // arm64:"AND [$]31," "MOVD [$]1," "LSL" "ORR"
+       // loong64:"MOVV [$]1," "SLL " "OR "
        // riscv64:"ANDI" "SLL" "OR"
        n += b | (1 << (a & 31))
 
        // amd64:"ORL [$]-2147483648,"
        // arm64:"ORR [$]-2147483648,"
+       // loong64:"OR [$]-2147483648,"
        // riscv64:"ORI [$]-2147483648,"
        n += a | (1 << 31)
 
        // amd64:"ORL [$]268435456,"
        // arm64:"ORR [$]268435456,"
+       // loong64:"OR [$]268435456,"
        // riscv64:"ORI [$]268435456,"
        n += a | (1 << 28)
 
        // amd64:"ORL [$]1,"
        // arm64:"ORR [$]1,"
+       // loong64:"OR [$]1,"
        // riscv64:"ORI [$]1,"
        n += a | (1 << 0)
 
@@ -341,21 +389,25 @@ func bitsSetU32(a, b uint32) (n uint32) {
 func bitsClearU32(a, b uint32) (n uint32) {
        // amd64:"BTRL"
        // arm64:"AND [$]31," "MOVD [$]1," "LSL" "BIC"
+       // loong64:"MOVV [$]1," "SLL R" "ANDN"
        // riscv64:"ANDI" "SLL" "ANDN"
        n += b &^ (1 << (a & 31))
 
        // amd64:"ANDL [$]2147483647,"
        // arm64:"AND [$]2147483647,"
+       // loong64:"AND [$]2147483647,"
        // riscv64:"ANDI [$]2147483647,"
        n += a &^ (1 << 31)
 
        // amd64:"ANDL [$]-268435457,"
        // arm64:"AND [$]-268435457,"
+       // loong64:"AND [$]-268435457,"
        // riscv64:"ANDI [$]-268435457,"
        n += a &^ (1 << 28)
 
        // amd64:"ANDL [$]-2,"
        // arm64:"AND [$]-2,"
+       // loong64:"AND [$]-2,"
        // riscv64:"ANDI [$]-2,"
        n += a &^ (1 << 0)
 
@@ -365,21 +417,25 @@ func bitsClearU32(a, b uint32) (n uint32) {
 func bitsFlipU32(a, b uint32) (n uint32) {
        // amd64:"BTCL"
        // arm64:"AND [$]31," "MOVD [$]1," "LSL" "EOR"
+       // loong64:"MOVV [$]1," "SLL R" "XOR"
        // riscv64:"ANDI" "SLL" "XOR "
        n += b ^ (1 << (a & 31))
 
        // amd64:"XORL [$]-2147483648,"
        // arm64:"EOR [$]-2147483648,"
+       // loong64:"XOR [$]-2147483648,"
        // riscv64:"XORI [$]-2147483648,"
        n += a ^ (1 << 31)
 
        // amd64:"XORL [$]268435456,"
        // arm64:"EOR [$]268435456,"
+       // loong64:"XOR [$]268435456,"
        // riscv64:"XORI [$]268435456,"
        n += a ^ (1 << 28)
 
        // amd64:"XORL [$]1,"
        // arm64:"EOR [$]1,"
+       // loong64:"XOR [$]1,"
        // riscv64:"XORI [$]1,"
        n += a ^ (1 << 0)
 
@@ -400,6 +456,7 @@ func bitsOpOnMem(a []uint32, b, c, d uint32) {
 func bitsCheckMostNegative(b uint8) bool {
        // amd64:"TESTB"
        // arm64:"TSTW" "CSET"
+       // loong64:"AND [$]128," "SGTU"
        // riscv64:"ANDI [$]128," "SNEZ" -"ADDI"
        return b&0x80 == 0x80
 }
@@ -431,18 +488,22 @@ func bitsAndNot(x, y uint32) uint32 {
 
 func bitsXorNot(x, y, z uint32, a []uint32, n, m uint64) uint64 {
        // arm64:`EON `,-`EOR`,-`MVN`
+       // loong64:"NOR" "XOR"
        // riscv64:"XNOR " -"MOV [$]" -"XOR"
        a[0] = x ^ (y ^ 0xffffffff)
 
        // arm64:`EON `,-`EOR`,-`MVN`
+       // loong64:"XOR" "NOR"
        // riscv64:"XNOR" -"XOR"
        a[1] = ^(y ^ z)
 
        // arm64:`EON `,-`XOR`
+       // loong64:"NOR" "XOR"
        // riscv64:"XNOR" -"XOR" -"NOT"
        a[2] = x ^ ^z
 
        // arm64:`EON `,-`EOR`,-`MVN`
+       // loong64:"NOR" "XOR"
        // riscv64:"XNOR" -"MOV [$]" -"XOR"
        return n ^ (m ^ 0xffffffffffffffff)
 }
@@ -465,6 +526,7 @@ func bitsNotOr(x int64, a []int64) {
 
 func bitsSetPowerOf2Test(x int) bool {
        // amd64:"BTL [$]3"
+       // loong64:"AND [$]8," "SGTU"
        // riscv64:"ANDI [$]8," "SNEZ" -"ADDI"
        return x&8 == 8
 }
@@ -472,6 +534,7 @@ func bitsSetPowerOf2Test(x int) bool {
 func bitsSetTest(x int) bool {
        // amd64:"ANDL [$]9, AX"
        // amd64:"CMPQ AX, [$]9"
+       // loong64:"AND [$]9," "XOR" "SGTU"
        // riscv64:"ANDI [$]9," "ADDI [$]-9," "SEQZ"
        return x&9 == 9
 }