| /* | |
| * Copyright (c) 2017 ARM Ltd | |
| * All rights reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions | |
| * are met: | |
| * 1. Redistributions of source code must retain the above copyright | |
| * notice, this list of conditions and the following disclaimer. | |
| * 2. 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. | |
| * 3. The name of the company may not be used to endorse or promote | |
| * products derived from this software without specific prior written | |
| * permission. | |
| * | |
| * THIS SOFTWARE IS PROVIDED BY ARM LTD ``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 ARM LTD 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. | |
| */ | |
| /* Assumptions: | |
| * | |
| * ARMv8-a, AArch64, unaligned accesses. | |
| */ | |
| #include <private/bionic_asm.h> | |
| #define L(l) .L ## l | |
| /* Parameters and result. */ | |
| #define src1 x0 | |
| #define src2 x1 | |
| #define limit x2 | |
| #define result w0 | |
| /* Internal variables. */ | |
| #define data1 x3 | |
| #define data1w w3 | |
| #define data1h x4 | |
| #define data2 x5 | |
| #define data2w w5 | |
| #define data2h x6 | |
| #define tmp1 x7 | |
| #define tmp2 x8 | |
| /* Small inputs of less than 8 bytes are handled separately. This allows the | |
| main code to be speed up using unaligned loads since there are now at least | |
| 8 bytes to be compared. If the first 8 bytes are equal, align src1. | |
| This ensures each iteration does at most one unaligned access even if both | |
| src1 and src2 are unaligned, and mutually aligned inputs behave as if | |
| aligned. After the main loop, process the last 16 bytes using unaligned | |
| accesses. */ | |
| ENTRY(memcmp) | |
| .p2align 6 | |
| subs limit, limit, 8 | |
| b.lo L(less8) | |
| /* Limit >= 8, so check first 8 bytes using unaligned loads. */ | |
| ldr data1, [src1], 8 | |
| ldr data2, [src2], 8 | |
| cmp data1, data2 | |
| b.ne L(return) | |
| subs limit, limit, 8 | |
| b.gt L(more16) | |
| ldr data1, [src1, limit] | |
| ldr data2, [src2, limit] | |
| b L(return) | |
| L(more16): | |
| ldr data1, [src1], 8 | |
| ldr data2, [src2], 8 | |
| cmp data1, data2 | |
| bne L(return) | |
| /* Jump directly to comparing the last 16 bytes for 32 byte (or less) | |
| strings. */ | |
| subs limit, limit, 16 | |
| b.ls L(last_bytes) | |
| /* We overlap loads between 0-32 bytes at either side of SRC1 when we | |
| try to align, so limit it only to strings larger than 128 bytes. */ | |
| cmp limit, 96 | |
| b.ls L(loop16) | |
| /* Align src1 and adjust src2 with bytes not yet done. */ | |
| and tmp1, src1, 15 | |
| add limit, limit, tmp1 | |
| sub src1, src1, tmp1 | |
| sub src2, src2, tmp1 | |
| /* Loop performing 16 bytes per iteration using aligned src1. | |
| Limit is pre-decremented by 16 and must be larger than zero. | |
| Exit if <= 16 bytes left to do or if the data is not equal. */ | |
| .p2align 4 | |
| L(loop16): | |
| ldp data1, data1h, [src1], 16 | |
| ldp data2, data2h, [src2], 16 | |
| subs limit, limit, 16 | |
| ccmp data1, data2, 0, hi | |
| ccmp data1h, data2h, 0, eq | |
| b.eq L(loop16) | |
| cmp data1, data2 | |
| bne L(return) | |
| mov data1, data1h | |
| mov data2, data2h | |
| cmp data1, data2 | |
| bne L(return) | |
| /* Compare last 1-16 bytes using unaligned access. */ | |
| L(last_bytes): | |
| add src1, src1, limit | |
| add src2, src2, limit | |
| ldp data1, data1h, [src1] | |
| ldp data2, data2h, [src2] | |
| cmp data1, data2 | |
| bne L(return) | |
| mov data1, data1h | |
| mov data2, data2h | |
| cmp data1, data2 | |
| /* Compare data bytes and set return value to 0, -1 or 1. */ | |
| L(return): | |
| #ifndef __AARCH64EB__ | |
| rev data1, data1 | |
| rev data2, data2 | |
| #endif | |
| cmp data1, data2 | |
| L(ret_eq): | |
| cset result, ne | |
| cneg result, result, lo | |
| ret | |
| .p2align 4 | |
| /* Compare up to 8 bytes. Limit is [-8..-1]. */ | |
| L(less8): | |
| adds limit, limit, 4 | |
| b.lo L(less4) | |
| ldr data1w, [src1], 4 | |
| ldr data2w, [src2], 4 | |
| cmp data1w, data2w | |
| b.ne L(return) | |
| sub limit, limit, 4 | |
| L(less4): | |
| adds limit, limit, 4 | |
| beq L(ret_eq) | |
| L(byte_loop): | |
| ldrb data1w, [src1], 1 | |
| ldrb data2w, [src2], 1 | |
| subs limit, limit, 1 | |
| ccmp data1w, data2w, 0, ne /* NZCV = 0b0000. */ | |
| b.eq L(byte_loop) | |
| sub result, data1w, data2w | |
| ret | |
| END(memcmp) |