| // Copyright 2018 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| //go:build ppc64 || ppc64le |
| |
| #include "go_asm.h" |
| #include "textflag.h" |
| |
| TEXT ·Compare<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-56 |
| // incoming: |
| // R3 a addr -> R5 |
| // R4 a len -> R3 |
| // R5 a cap unused |
| // R6 b addr -> R6 |
| // R7 b len -> R4 |
| // R8 b cap unused |
| MOVD R3, R5 |
| MOVD R4, R3 |
| MOVD R7, R4 |
| CMP R5,R6,CR7 |
| CMP R3,R4,CR6 |
| BEQ CR7,equal |
| MOVBZ internal∕cpu·PPC64+const_offsetPPC64HasPOWER9(SB), R16 |
| CMP R16,$1 |
| BNE power8 |
| BR cmpbodyp9<>(SB) |
| power8: |
| BR cmpbody<>(SB) |
| equal: |
| BEQ CR6,done |
| MOVD $1, R8 |
| BGT CR6,greater |
| NEG R8 |
| greater: |
| MOVD R8, R3 |
| RET |
| done: |
| MOVD $0, R3 |
| RET |
| |
| TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-40 |
| // incoming: |
| // R3 a addr -> R5 |
| // R4 a len -> R3 |
| // R5 b addr -> R6 |
| // R6 b len -> R4 |
| MOVD R6, R7 |
| MOVD R5, R6 |
| MOVD R3, R5 |
| MOVD R4, R3 |
| MOVD R7, R4 |
| CMP R5,R6,CR7 |
| CMP R3,R4,CR6 |
| BEQ CR7,equal |
| MOVBZ internal∕cpu·PPC64+const_offsetPPC64HasPOWER9(SB), R16 |
| CMP R16,$1 |
| BNE power8 |
| BR cmpbodyp9<>(SB) |
| power8: |
| BR cmpbody<>(SB) |
| equal: |
| BEQ CR6,done |
| MOVD $1, R8 |
| BGT CR6,greater |
| NEG R8 |
| greater: |
| MOVD R8, R3 |
| RET |
| |
| done: |
| MOVD $0, R3 |
| RET |
| |
| #ifdef GOARCH_ppc64le |
| DATA byteswap<>+0(SB)/8, $0x0706050403020100 |
| DATA byteswap<>+8(SB)/8, $0x0f0e0d0c0b0a0908 |
| GLOBL byteswap<>+0(SB), RODATA, $16 |
| #define SWAP V21 |
| #endif |
| |
| // Do an efficient memcmp for ppc64le/ppc64/POWER8 |
| // R3 = a len |
| // R4 = b len |
| // R5 = a addr |
| // R6 = b addr |
| // On exit: |
| // R3 = return value |
| TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0-0 |
| MOVD R3,R8 // set up length |
| CMP R3,R4,CR2 // unequal? |
| BLT CR2,setuplen // BLT CR2 |
| MOVD R4,R8 // use R4 for comparison len |
| setuplen: |
| CMP R8,$32 // optimize >= 32 |
| MOVD R8,R9 |
| BLT setup8a // optimize < 32 |
| MOVD $16,R10 // set offsets to load into vectors |
| CMP R8,$64 |
| BLT cmp32 // process size 32-63 |
| |
| DCBT (R5) // optimize >= 64 |
| DCBT (R6) // cache hint |
| MOVD $32,R11 // set offsets to load into vector |
| MOVD $48,R12 // set offsets to load into vector |
| |
| loop64a:// process size 64 and greater |
| LXVD2X (R5)(R0),V3 // load bytes of A at offset 0 into vector |
| LXVD2X (R6)(R0),V4 // load bytes of B at offset 0 into vector |
| VCMPEQUDCC V3,V4,V1 |
| BGE CR6,different // jump out if its different |
| |
| LXVD2X (R5)(R10),V3 // load bytes of A at offset 16 into vector |
| LXVD2X (R6)(R10),V4 // load bytes of B at offset 16 into vector |
| |
| VCMPEQUDCC V3,V4,V1 |
| BGE CR6,different |
| |
| LXVD2X (R5)(R11),V3 // load bytes of A at offset 32 into vector |
| LXVD2X (R6)(R11),V4 // load bytes of B at offset 32 into vector |
| |
| VCMPEQUDCC V3,V4,V1 |
| BGE CR6,different |
| |
| LXVD2X (R5)(R12),V3 // load bytes of A at offset 64 into vector |
| LXVD2X (R6)(R12),V4 // load bytes of B at offset 64 into vector |
| |
| VCMPEQUDCC V3,V4,V1 |
| BGE CR6,different |
| |
| ADD $-64,R9,R9 // reduce remaining size by 64 |
| ADD $64,R5,R5 // increment to next 64 bytes of A |
| ADD $64,R6,R6 // increment to next 64 bytes of B |
| CMPU R9,$64 |
| BGE loop64a // loop back to loop64a only if there are >= 64 bytes remaining |
| |
| CMPU R9,$32 |
| BGE cmp32 // loop to cmp32 if there are 32-64 bytes remaining |
| CMPU R9,$0 |
| BNE rem // loop to rem if the remainder is not 0 |
| |
| BEQ CR2,equal // remainder is zero, jump to equal if len(A)==len(B) |
| BLT CR2,less // jump to less if len(A)<len(B) |
| BR greater // jump to greater otherwise |
| cmp32: |
| LXVD2X (R5)(R0),V3 // load bytes of A at offset 0 into vector |
| LXVD2X (R6)(R0),V4 // load bytes of B at offset 0 into vector |
| |
| VCMPEQUDCC V3,V4,V1 |
| BGE CR6,different |
| |
| LXVD2X (R5)(R10),V3 // load bytes of A at offset 16 into vector |
| LXVD2X (R6)(R10),V4 // load bytes of B at offset 16 into vector |
| |
| VCMPEQUDCC V3,V4,V1 |
| BGE CR6,different |
| |
| ADD $-32,R9,R9 // reduce remaining size by 32 |
| ADD $32,R5,R5 // increment to next 32 bytes of A |
| ADD $32,R6,R6 // increment to next 32 bytes of B |
| CMPU R9,$0 |
| BNE rem // loop to rem if the remainder is not 0 |
| BEQ CR2,equal // remainder is zero, jump to equal if len(A)==len(B) |
| BLT CR2,less // jump to less if len(A)<len(B) |
| BR greater // jump to greater otherwise |
| rem: |
| MOVD R9,R8 |
| ANDCC $24,R8,R9 // Any 8 byte chunks? |
| BEQ leftover // and result is 0 |
| BR setup8a |
| |
| different: |
| #ifdef GOARCH_ppc64le |
| MOVD $byteswap<>+00(SB), R16 |
| LXVD2X (R16)(R0),SWAP // Set up swap string |
| |
| VPERM V3,V3,SWAP,V3 |
| VPERM V4,V4,SWAP,V4 |
| #endif |
| MFVSRD VS35,R16 // move upper doublwords of A and B into GPR for comparison |
| MFVSRD VS36,R10 |
| |
| CMPU R16,R10 |
| BEQ lower |
| BGT greater |
| MOVD $-1,R3 // return value if A < B |
| RET |
| lower: |
| VSLDOI $8,V3,V3,V3 // move lower doublwords of A and B into GPR for comparison |
| MFVSRD VS35,R16 |
| VSLDOI $8,V4,V4,V4 |
| MFVSRD VS36,R10 |
| |
| CMPU R16,R10 |
| BGT greater |
| MOVD $-1,R3 // return value if A < B |
| RET |
| setup8a: |
| SRADCC $3,R8,R9 // get the 8 byte count |
| BEQ leftover // shifted value is 0 |
| CMPU R8,$8 // optimize 8byte move |
| BEQ size8 |
| CMPU R8,$16 |
| BEQ size16 |
| MOVD R9,CTR // loop count for doublewords |
| loop8: |
| #ifdef GOARCH_ppc64le |
| MOVDBR (R5+R0),R16 // doublewords to compare |
| MOVDBR (R6+R0),R10 // LE compare order |
| #else |
| MOVD (R5+R0),R16 // doublewords to compare |
| MOVD (R6+R0),R10 // BE compare order |
| #endif |
| ADD $8,R5 |
| ADD $8,R6 |
| CMPU R16,R10 // match? |
| BC 8,2,loop8 // bt ctr <> 0 && cr |
| BGT greater |
| BLT less |
| leftover: |
| ANDCC $7,R8,R9 // check for leftover bytes |
| BEQ zeroremainder |
| simplecheck: |
| MOVD R0,R14 |
| CMP R9,$4 // process 4 bytes |
| BLT halfword |
| #ifdef GOARCH_ppc64le |
| MOVWBR (R5)(R14),R10 |
| MOVWBR (R6)(R14),R11 |
| #else |
| MOVWZ (R5)(R14),R10 |
| MOVWZ (R6)(R14),R11 |
| #endif |
| CMPU R10,R11 |
| BGT greater |
| BLT less |
| ADD $-4,R9 |
| ADD $4,R14 |
| PCALIGN $16 |
| |
| halfword: |
| CMP R9,$2 // process 2 bytes |
| BLT byte |
| #ifdef GOARCH_ppc64le |
| MOVHBR (R5)(R14),R10 |
| MOVHBR (R6)(R14),R11 |
| #else |
| MOVHZ (R5)(R14),R10 |
| MOVHZ (R6)(R14),R11 |
| #endif |
| CMPU R10,R11 |
| BGT greater |
| BLT less |
| ADD $-2,R9 |
| ADD $2,R14 |
| PCALIGN $16 |
| byte: |
| CMP R9,$0 // process 1 byte |
| BEQ skip |
| MOVBZ (R5)(R14),R10 |
| MOVBZ (R6)(R14),R11 |
| CMPU R10,R11 |
| BGT greater |
| BLT less |
| PCALIGN $16 |
| skip: |
| BEQ CR2,equal |
| BGT CR2,greater |
| |
| less: MOVD $-1,R3 // return value if A < B |
| RET |
| size16: |
| LXVD2X (R5)(R0),V3 // load bytes of A at offset 0 into vector |
| LXVD2X (R6)(R0),V4 // load bytes of B at offset 0 into vector |
| VCMPEQUDCC V3,V4,V1 |
| BGE CR6,different |
| zeroremainder: |
| BEQ CR2,equal // remainder is zero, jump to equal if len(A)==len(B) |
| BLT CR2,less // jump to less if len(A)<len(B) |
| BR greater // jump to greater otherwise |
| size8: |
| #ifdef GOARCH_ppc64le |
| MOVDBR (R5+R0),R16 // doublewords to compare |
| MOVDBR (R6+R0),R10 // LE compare order |
| #else |
| MOVD (R5+R0),R16 // doublewords to compare |
| MOVD (R6+R0),R10 // BE compare order |
| #endif |
| CMPU R16,R10 // match? |
| BGT greater |
| BLT less |
| BGT CR2,greater // 2nd len > 1st len |
| BLT CR2,less // 2nd len < 1st len |
| equal: |
| MOVD $0, R3 // return value if A == B |
| RET |
| greater: |
| MOVD $1,R3 // return value if A > B |
| RET |
| |
| // Do an efficient memcmp for ppc64le/ppc64/POWER9 |
| // R3 = a len |
| // R4 = b len |
| // R5 = a addr |
| // R6 = b addr |
| // On exit: |
| // R3 = return value |
| TEXT cmpbodyp9<>(SB),NOSPLIT|NOFRAME,$0-0 |
| MOVD R3,R8 // set up length |
| CMP R3,R4,CR2 // unequal? |
| BLT CR2,setuplen // BLT CR2 |
| MOVD R4,R8 // use R4 for comparison len |
| setuplen: |
| CMP R8,$16 // optimize for size<16 |
| MOVD R8,R9 |
| BLT simplecheck |
| MOVD $16,R10 // set offsets to load into vectors |
| CMP R8,$32 // optimize for size 16-31 |
| BLT cmp16 |
| CMP R8,$64 |
| BLT cmp32 // optimize for size 32-63 |
| DCBT (R5) // optimize for size>=64 |
| DCBT (R6) // cache hint |
| |
| MOVD $32,R11 // set offsets to load into vector |
| MOVD $48,R12 // set offsets to load into vector |
| |
| loop64a:// process size 64 and greater |
| LXVB16X (R0)(R5),V3 // load bytes of A at offset 0 into vector |
| LXVB16X (R0)(R6),V4 // load bytes of B at offset 0 into vector |
| VCMPNEBCC V3,V4,V1 // record comparison into V1 |
| BNE CR6,different // jump out if its different |
| |
| LXVB16X (R10)(R5),V3 // load bytes of A at offset 16 into vector |
| LXVB16X (R10)(R6),V4 // load bytes of B at offset 16 into vector |
| VCMPNEBCC V3,V4,V1 |
| BNE CR6,different |
| |
| LXVB16X (R11)(R5),V3 // load bytes of A at offset 32 into vector |
| LXVB16X (R11)(R6),V4 // load bytes of B at offset 32 into vector |
| VCMPNEBCC V3,V4,V1 |
| BNE CR6,different |
| |
| LXVB16X (R12)(R5),V3 // load bytes of A at offset 48 into vector |
| LXVB16X (R12)(R6),V4 // load bytes of B at offset 48 into vector |
| VCMPNEBCC V3,V4,V1 |
| BNE CR6,different |
| |
| ADD $-64,R9,R9 // reduce remaining size by 64 |
| ADD $64,R5,R5 // increment to next 64 bytes of A |
| ADD $64,R6,R6 // increment to next 64 bytes of B |
| CMPU R9,$64 |
| BGE loop64a // loop back to loop64a only if there are >= 64 bytes remaining |
| |
| CMPU R9,$32 |
| BGE cmp32 // loop to cmp32 if there are 32-64 bytes remaining |
| CMPU R9,$16 |
| BGE cmp16 // loop to cmp16 if there are 16-31 bytes left |
| CMPU R9,$0 |
| BNE simplecheck // loop to simplecheck for remaining bytes |
| |
| BEQ CR2,equal // remainder is zero, jump to equal if len(A)==len(B) |
| BLT CR2,less // jump to less if len(A)<len(B) |
| BR greater // jump to greater otherwise |
| cmp32: |
| LXVB16X (R0)(R5),V3 // load bytes of A at offset 0 into vector |
| LXVB16X (R0)(R6),V4 // load bytes of B at offset 0 into vector |
| |
| VCMPNEBCC V3,V4,V1 // record comparison into V1 |
| BNE CR6,different // jump out if its different |
| |
| LXVB16X (R10)(R5),V3 // load bytes of A at offset 16 into vector |
| LXVB16X (R10)(R6),V4 // load bytes of B at offset 16 into vector |
| VCMPNEBCC V3,V4,V1 |
| BNE CR6,different |
| |
| ADD $-32,R9,R9 // reduce remaining size by 32 |
| ADD $32,R5,R5 // increment to next 32 bytes of A |
| ADD $32,R6,R6 // increment to next 32 bytes of B |
| CMPU R9,$16 // loop to cmp16 if there are 16-31 bytes left |
| BGE cmp16 |
| CMPU R9,$0 |
| BNE simplecheck // loop to simplecheck for remainder bytes |
| BEQ CR2,equal // remainder is zero, jump to equal if len(A)==len(B) |
| BLT CR2,less // jump to less if len(A)<len(B) |
| BR greater // jump to greater otherwise |
| different: |
| |
| MFVSRD VS35,R16 // move upper doublwords of A and B into GPR for comparison |
| MFVSRD VS36,R10 |
| |
| CMPU R16,R10 |
| BEQ lower |
| BGT greater |
| MOVD $-1,R3 // return value if A < B |
| RET |
| lower: |
| MFVSRLD VS35,R16 // next move lower doublewords of A and B into GPR for comparison |
| MFVSRLD VS36,R10 |
| |
| CMPU R16,R10 |
| BGT greater |
| MOVD $-1,R3 // return value if A < B |
| RET |
| |
| greater: |
| MOVD $1,R3 // return value if A > B |
| RET |
| cmp16: |
| ANDCC $16,R9,R31 |
| BEQ tail |
| |
| LXVB16X (R0)(R5),V3 // load bytes of A at offset 16 into vector |
| LXVB16X (R0)(R6),V4 // load bytes of B at offset 16 into vector |
| VCMPEQUDCC V3,V4,V1 |
| BGE CR6,different |
| |
| ADD $16,R5 |
| ADD $16,R6 |
| tail: |
| ANDCC $15,R9 // Load the last 16 bytes (we know there are at least 32b) |
| BEQ end |
| |
| ADD R9,R5 |
| ADD R9,R6 |
| MOVD $-16,R10 |
| |
| LXVB16X (R10)(R5),V3 // load bytes of A at offset 16 into vector |
| LXVB16X (R10)(R6),V4 // load bytes of B at offset 16 into vector |
| VCMPEQUDCC V3,V4,V1 |
| BGE CR6,different |
| end: |
| BEQ CR2,equal // remainder is zero, jump to equal if len(A)==len(B) |
| BLT CR2,less // jump to less if BLT CR2 that is, len(A)<len(B) |
| BR greater // jump to greater otherwise |
| simplecheck: |
| MOVD $0,R14 // process 8 bytes |
| CMP R9,$8 |
| BLT word |
| #ifdef GOARCH_ppc64le |
| MOVDBR (R5+R14),R10 |
| MOVDBR (R6+R14),R11 |
| #else |
| MOVD (R5+R14),R10 |
| MOVD (R6+R14),R11 |
| #endif |
| CMPU R10,R11 |
| BGT greater |
| BLT less |
| ADD $8,R14 |
| ADD $-8,R9 |
| PCALIGN $16 |
| word: |
| CMP R9,$4 // process 4 bytes |
| BLT halfword |
| #ifdef GOARCH_ppc64le |
| MOVWBR (R5+R14),R10 |
| MOVWBR (R6+R14),R11 |
| #else |
| MOVWZ (R5+R14),R10 |
| MOVWZ (R6+R14),R11 |
| #endif |
| CMPU R10,R11 |
| BGT greater |
| BLT less |
| ADD $4,R14 |
| ADD $-4,R9 |
| PCALIGN $16 |
| halfword: |
| CMP R9,$2 // process 2 bytes |
| BLT byte |
| #ifdef GOARCH_ppc64le |
| MOVHBR (R5+R14),R10 |
| MOVHBR (R6+R14),R11 |
| #else |
| MOVHZ (R5+R14),R10 |
| MOVHZ (R6+R14),R11 |
| #endif |
| CMPU R10,R11 |
| BGT greater |
| BLT less |
| ADD $2,R14 |
| ADD $-2,R9 |
| PCALIGN $16 |
| byte: |
| CMP R9,$0 // process 1 byte |
| BEQ skip |
| MOVBZ (R5+R14),R10 |
| MOVBZ (R6+R14),R11 |
| CMPU R10,R11 |
| BGT greater |
| BLT less |
| PCALIGN $16 |
| skip: |
| BEQ CR2,equal |
| BGT CR2,greater |
| less: |
| MOVD $-1,R3 // return value if A < B |
| RET |
| equal: |
| MOVD $0, R3 // return value if A == B |
| RET |
