| /* |
| * Copyright (c) 2017 Imagination Technologies. |
| * |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with |
| * the distribution. |
| * * Neither the name of Imagination Technologies nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #ifdef __ANDROID__ |
| # include <private/bionic_asm.h> |
| #elif _LIBC |
| # include <sysdep.h> |
| # include <regdef.h> |
| # include <sys/asm.h> |
| #elif _COMPILING_NEWLIB |
| # include "machine/asm.h" |
| # include "machine/regdef.h" |
| #else |
| # include <regdef.h> |
| # include <sys/asm.h> |
| #endif |
| |
| #if __mips64 |
| # define NSIZE 8 |
| # define LW ld |
| # define EXT dext |
| # define SRL dsrl |
| # define SLL dsll |
| # define SUBU dsubu |
| #else |
| # define NSIZE 4 |
| # define LW lw |
| # define EXT ext |
| # define SRL srl |
| # define SLL sll |
| # define SUBU subu |
| #endif |
| |
| /* Technically strcmp should not read past the end of the strings being |
| compared. We will read a full word that may contain excess bits beyond |
| the NULL string terminator but unless ENABLE_READAHEAD is set, we will not |
| read the next word after the end of string. Setting ENABLE_READAHEAD will |
| improve performance but is technically illegal based on the definition of |
| strcmp. */ |
| #ifdef ENABLE_READAHEAD |
| # define DELAY_READ |
| #else |
| # define DELAY_READ nop |
| #endif |
| |
| /* Testing on a little endian machine showed using CLZ was a |
| performance loss, so we are not turning it on by default. */ |
| #if defined(ENABLE_CLZ) && (__mips_isa_rev > 1) |
| # define USE_CLZ |
| #endif |
| |
| /* Some asm.h files do not have the L macro definition. */ |
| #ifndef L |
| # if _MIPS_SIM == _ABIO32 |
| # define L(label) $L ## label |
| # else |
| # define L(label) .L ## label |
| # endif |
| #endif |
| |
| /* Some asm.h files do not have the PTR_ADDIU macro definition. */ |
| #ifndef PTR_ADDIU |
| # if _MIPS_SIM == _ABIO32 |
| # define PTR_ADDIU addiu |
| # else |
| # define PTR_ADDIU daddiu |
| # endif |
| #endif |
| |
| /* It might seem better to do the 'beq' instruction between the two 'lbu' |
| instructions so that the nop is not needed but testing showed that this |
| code is actually faster (based on glibc strcmp test). */ |
| #define BYTECMP01(OFFSET) \ |
| lbu $v0, OFFSET($a0); \ |
| lbu $v1, OFFSET($a1); \ |
| beq $v0, $zero, L(bexit01); \ |
| nop; \ |
| bne $v0, $v1, L(bexit01) |
| |
| #define BYTECMP89(OFFSET) \ |
| lbu $t8, OFFSET($a0); \ |
| lbu $t9, OFFSET($a1); \ |
| beq $t8, $zero, L(bexit89); \ |
| nop; \ |
| bne $t8, $t9, L(bexit89) |
| |
| /* Allow the routine to be named something else if desired. */ |
| #ifndef STRCMP_NAME |
| # define STRCMP_NAME strcmp |
| #endif |
| |
| #ifdef __ANDROID__ |
| LEAF(STRCMP_NAME, 0) |
| #else |
| LEAF(STRCMP_NAME) |
| #endif |
| .set nomips16 |
| .set noreorder |
| |
| andi $t1, $a1, (NSIZE - 1) |
| beqz $t1, L(exitalign) |
| or $t0, $zero, NSIZE |
| SUBU $t1, $t0, $t1 #process (NSIZE - 1) bytes at max |
| |
| L(alignloop): #do by bytes until a1 aligned |
| BYTECMP01(0) |
| SUBU $t1, $t1, 0x1 |
| PTR_ADDIU $a0, $a0, 0x1 |
| bnez $t1, L(alignloop) |
| PTR_ADDIU $a1, $a1, 0x1 |
| |
| L(exitalign): |
| |
| /* string a1 is NSIZE byte aligned at this point. */ |
| |
| lui $t8, 0x0101 |
| ori $t8, 0x0101 |
| lui $t9, 0x7f7f |
| ori $t9, 0x7f7f |
| #if __mips64 |
| dsll $t1, $t8, 32 |
| or $t8, $t1 |
| dsll $t1, $t9, 32 |
| or $t9, $t1 |
| #endif |
| |
| andi $t2, $a0, (NSIZE - 1) #check if a0 aligned |
| SUBU $t3, $t0, $t2 #t3 will be used as shifter |
| bnez $t2, L(uloopenter) |
| SUBU $a2, $a0, $t2 #bring back a0 to aligned position |
| |
| #define STRCMPW(OFFSET) \ |
| LW $v0, OFFSET($a0); \ |
| LW $v1, OFFSET($a1); \ |
| SUBU $t0, $v0, $t8; \ |
| bne $v0, $v1, L(worddiff); \ |
| nor $t1, $v0, $t9; \ |
| and $t0, $t0, $t1; \ |
| bne $t0, $zero, L(returnzero);\ |
| |
| L(wordloop): |
| STRCMPW(0 * NSIZE) |
| DELAY_READ |
| STRCMPW(1 * NSIZE) |
| DELAY_READ |
| STRCMPW(2 * NSIZE) |
| DELAY_READ |
| STRCMPW(3 * NSIZE) |
| DELAY_READ |
| STRCMPW(4 * NSIZE) |
| DELAY_READ |
| STRCMPW(5 * NSIZE) |
| DELAY_READ |
| STRCMPW(6 * NSIZE) |
| DELAY_READ |
| STRCMPW(7 * NSIZE) |
| PTR_ADDIU $a0, $a0, (8 * NSIZE) |
| b L(wordloop) |
| PTR_ADDIU $a1, $a1, (8 * NSIZE) |
| |
| #define USTRCMPW(OFFSET) \ |
| LW $v1, OFFSET($a1); \ |
| SUBU $t0, $v0, $t8; \ |
| nor $t1, $v0, $t9; \ |
| and $t0, $t0, $t1; \ |
| bne $t0, $zero, L(worddiff); \ |
| SRL $v0, $t2; \ |
| LW $a3, (OFFSET + NSIZE)($a2); \ |
| SUBU $t0, $v1, $t8; \ |
| SLL $t1, $a3, $t3; \ |
| or $v0, $v0, $t1; \ |
| bne $v0, $v1, L(worddiff); \ |
| nor $t1, $v1, $t9; \ |
| and $t0, $t0, $t1; \ |
| bne $t0, $zero, L(returnzero); \ |
| move $v0, $a3;\ |
| |
| L(uloopenter): |
| LW $v0, 0($a2) |
| SLL $t2, 3 #multiply by 8 |
| SLL $t3, 3 #multiply by 8 |
| li $a3, -1 #all 1s |
| SRL $a3, $t3 |
| or $v0, $a3 #replace with all 1s if zeros in unintented read |
| |
| L(uwordloop): |
| USTRCMPW(0 * NSIZE) |
| USTRCMPW(1 * NSIZE) |
| USTRCMPW(2 * NSIZE) |
| USTRCMPW(3 * NSIZE) |
| USTRCMPW(4 * NSIZE) |
| USTRCMPW(5 * NSIZE) |
| USTRCMPW(6 * NSIZE) |
| USTRCMPW(7 * NSIZE) |
| PTR_ADDIU $a2, $a2, (8 * NSIZE) |
| b L(uwordloop) |
| PTR_ADDIU $a1, $a1, (8 * NSIZE) |
| |
| L(returnzero): |
| j $ra |
| move $v0, $zero |
| |
| #if __mips_isa_rev > 1 |
| #define EXT_COMPARE01(POS) \ |
| EXT $t0, $v0, POS, 8; \ |
| beq $t0, $zero, L(wexit01); \ |
| EXT $t1, $v1, POS, 8; \ |
| bne $t0, $t1, L(wexit01) |
| #define EXT_COMPARE89(POS) \ |
| EXT $t8, $v0, POS, 8; \ |
| beq $t8, $zero, L(wexit89); \ |
| EXT $t9, $v1, POS, 8; \ |
| bne $t8, $t9, L(wexit89) |
| #else |
| #define EXT_COMPARE01(POS) \ |
| SRL $t0, $v0, POS; \ |
| SRL $t1, $v1, POS; \ |
| andi $t0, $t0, 0xff; \ |
| beq $t0, $zero, L(wexit01); \ |
| andi $t1, $t1, 0xff; \ |
| bne $t0, $t1, L(wexit01) |
| #define EXT_COMPARE89(POS) \ |
| SRL $t8, $v0, POS; \ |
| SRL $t9, $v1, POS; \ |
| andi $t8, $t8, 0xff; \ |
| beq $t8, $zero, L(wexit89); \ |
| andi $t9, $t9, 0xff; \ |
| bne $t8, $t9, L(wexit89) |
| #endif |
| |
| L(worddiff): |
| #ifdef USE_CLZ |
| SUBU $t0, $v0, $t8 |
| nor $t1, $v0, $t9 |
| and $t1, $t0, $t1 |
| xor $t0, $v0, $v1 |
| or $t0, $t0, $t1 |
| # if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ |
| wsbh $t0, $t0 |
| rotr $t0, $t0, 16 |
| # endif |
| clz $t1, $t0 |
| and $t1, 0xf8 |
| # if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ |
| neg $t1 |
| addu $t1, 24 |
| # endif |
| rotrv $v0, $v0, $t1 |
| rotrv $v1, $v1, $t1 |
| and $v0, $v0, 0xff |
| and $v1, $v1, 0xff |
| j $ra |
| SUBU $v0, $v0, $v1 |
| #else /* USE_CLZ */ |
| # if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ |
| andi $t0, $v0, 0xff |
| beq $t0, $zero, L(wexit01) |
| andi $t1, $v1, 0xff |
| bne $t0, $t1, L(wexit01) |
| EXT_COMPARE89(8) |
| EXT_COMPARE01(16) |
| #ifndef __mips64 |
| SRL $t8, $v0, 24 |
| SRL $t9, $v1, 24 |
| #else |
| EXT_COMPARE89(24) |
| EXT_COMPARE01(32) |
| EXT_COMPARE89(40) |
| EXT_COMPARE01(48) |
| SRL $t8, $v0, 56 |
| SRL $t9, $v1, 56 |
| #endif |
| |
| # else /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ */ |
| #ifdef __mips64 |
| SRL $t0, $v0, 56 |
| beq $t0, $zero, L(wexit01) |
| SRL $t1, $v1, 56 |
| bne $t0, $t1, L(wexit01) |
| EXT_COMPARE89(48) |
| EXT_COMPARE01(40) |
| EXT_COMPARE89(32) |
| EXT_COMPARE01(24) |
| #else |
| SRL $t0, $v0, 24 |
| beq $t0, $zero, L(wexit01) |
| SRL $t1, $v1, 24 |
| bne $t0, $t1, L(wexit01) |
| #endif |
| EXT_COMPARE89(16) |
| EXT_COMPARE01(8) |
| |
| andi $t8, $v0, 0xff |
| andi $t9, $v1, 0xff |
| # endif /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ */ |
| |
| L(wexit89): |
| j $ra |
| SUBU $v0, $t8, $t9 |
| L(wexit01): |
| j $ra |
| SUBU $v0, $t0, $t1 |
| #endif /* USE_CLZ */ |
| |
| L(byteloop): |
| BYTECMP01(0) |
| BYTECMP89(1) |
| BYTECMP01(2) |
| BYTECMP89(3) |
| BYTECMP01(4) |
| BYTECMP89(5) |
| BYTECMP01(6) |
| BYTECMP89(7) |
| PTR_ADDIU $a0, $a0, 8 |
| b L(byteloop) |
| PTR_ADDIU $a1, $a1, 8 |
| |
| L(bexit01): |
| j $ra |
| SUBU $v0, $v0, $v1 |
| L(bexit89): |
| j $ra |
| SUBU $v0, $t8, $t9 |
| |
| .set at |
| .set reorder |
| |
| END(STRCMP_NAME) |
| #ifndef __ANDROID__ |
| # ifdef _LIBC |
| libc_hidden_builtin_def (STRCMP_NAME) |
| # endif |
| #endif |