eb149e954e
The attached patch provides a new implementation of strcmp for ARM, using LDRD instead of LDR whenever possible. For older architectures that do not support LDRD, this implementation uses the same algorithm as before. Testing and benchmarking: * Validation: successfully passes a test that compares different strings of length 1-128 and offsets 0-8 from a word boundary. Checked on qemu/A15/A9, ARM/Thumb mode, Big/Little Endian. * Integration with gcc: no regression on qemu for arm-none-eabi --with-cpu a15/a9 --with-mode arm/thumb. Change-Id: I9e230e1b99dbdc9119b69ee858a89038c516a4ea Signed-off-by: Vassilis Laganakos <vasileios.laganakos@arm.com>
787 lines
24 KiB
ArmAsm
787 lines
24 KiB
ArmAsm
/*
|
|
* Copyright (c) 2013 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.
|
|
*/
|
|
|
|
#include "arm_asm.h"
|
|
|
|
#ifdef __ARMEB__
|
|
#define S2LOMEM lsl
|
|
#define S2LOMEMEQ lsleq
|
|
#define S2HIMEM lsr
|
|
#define MSB 0x000000ff
|
|
#define LSB 0xff000000
|
|
#define BYTE0_OFFSET 24
|
|
#define BYTE1_OFFSET 16
|
|
#define BYTE2_OFFSET 8
|
|
#define BYTE3_OFFSET 0
|
|
#else /* not __ARMEB__ */
|
|
#define S2LOMEM lsr
|
|
#define S2LOMEMEQ lsreq
|
|
#define S2HIMEM lsl
|
|
#define BYTE0_OFFSET 0
|
|
#define BYTE1_OFFSET 8
|
|
#define BYTE2_OFFSET 16
|
|
#define BYTE3_OFFSET 24
|
|
#define MSB 0xff000000
|
|
#define LSB 0x000000ff
|
|
#endif /* not __ARMEB__ */
|
|
|
|
.syntax unified
|
|
|
|
#if defined (__thumb__)
|
|
.thumb
|
|
.thumb_func
|
|
#endif
|
|
.global strcmp
|
|
.type strcmp, %function
|
|
strcmp:
|
|
|
|
#if (defined (__thumb__) && !defined (__thumb2__))
|
|
1:
|
|
ldrb r2, [r0]
|
|
ldrb r3, [r1]
|
|
adds r0, r0, #1
|
|
adds r1, r1, #1
|
|
cmp r2, #0
|
|
beq 2f
|
|
cmp r2, r3
|
|
beq 1b
|
|
2:
|
|
subs r0, r2, r3
|
|
bx lr
|
|
#elif (defined (__OPTIMIZE_SIZE__) || defined (PREFER_SIZE_OVER_SPEED))
|
|
1:
|
|
ldrb r2, [r0], #1
|
|
ldrb r3, [r1], #1
|
|
cmp r2, #1
|
|
it cs
|
|
cmpcs r2, r3
|
|
beq 1b
|
|
subs r0, r2, r3
|
|
RETURN
|
|
|
|
|
|
#elif (defined (_ISA_THUMB_2) || defined (_ISA_ARM_6))
|
|
/* Use LDRD whenever possible. */
|
|
|
|
/* The main thing to look out for when comparing large blocks is that
|
|
the loads do not cross a page boundary when loading past the index
|
|
of the byte with the first difference or the first string-terminator.
|
|
|
|
For example, if the strings are identical and the string-terminator
|
|
is at index k, byte by byte comparison will not load beyond address
|
|
s1+k and s2+k; word by word comparison may load up to 3 bytes beyond
|
|
k; double word - up to 7 bytes. If the load of these bytes crosses
|
|
a page boundary, it might cause a memory fault (if the page is not mapped)
|
|
that would not have happened in byte by byte comparison.
|
|
|
|
If an address is (double) word aligned, then a load of a (double) word
|
|
from that address will not cross a page boundary.
|
|
Therefore, the algorithm below considers word and double-word alignment
|
|
of strings separately. */
|
|
|
|
/* High-level description of the algorithm.
|
|
|
|
* The fast path: if both strings are double-word aligned,
|
|
use LDRD to load two words from each string in every loop iteration.
|
|
* If the strings have the same offset from a word boundary,
|
|
use LDRB to load and compare byte by byte until
|
|
the first string is aligned to a word boundary (at most 3 bytes).
|
|
This is optimized for quick return on short unaligned strings.
|
|
* If the strings have the same offset from a double-word boundary,
|
|
use LDRD to load two words from each string in every loop iteration, as in the fast path.
|
|
* If the strings do not have the same offset from a double-word boundary,
|
|
load a word from the second string before the loop to initialize the queue.
|
|
Use LDRD to load two words from every string in every loop iteration.
|
|
Inside the loop, load the second word from the second string only after comparing
|
|
the first word, using the queued value, to guarantee safety across page boundaries.
|
|
* If the strings do not have the same offset from a word boundary,
|
|
use LDR and a shift queue. Order of loads and comparisons matters,
|
|
similarly to the previous case.
|
|
|
|
* Use UADD8 and SEL to compare words, and use REV and CLZ to compute the return value.
|
|
* The only difference between ARM and Thumb modes is the use of CBZ instruction.
|
|
* The only difference between big and little endian is the use of REV in little endian
|
|
to compute the return value, instead of MOV.
|
|
* No preload. [TODO.]
|
|
*/
|
|
|
|
.macro m_cbz reg label
|
|
#ifdef __thumb2__
|
|
cbz \reg, \label
|
|
#else /* not defined __thumb2__ */
|
|
cmp \reg, #0
|
|
beq \label
|
|
#endif /* not defined __thumb2__ */
|
|
.endm /* m_cbz */
|
|
|
|
.macro m_cbnz reg label
|
|
#ifdef __thumb2__
|
|
cbnz \reg, \label
|
|
#else /* not defined __thumb2__ */
|
|
cmp \reg, #0
|
|
bne \label
|
|
#endif /* not defined __thumb2__ */
|
|
.endm /* m_cbnz */
|
|
|
|
.macro init
|
|
/* Macro to save temporary registers and prepare magic values. */
|
|
subs sp, sp, #16
|
|
strd r4, r5, [sp, #8]
|
|
strd r6, r7, [sp]
|
|
mvn r6, #0 /* all F */
|
|
mov r7, #0 /* all 0 */
|
|
.endm /* init */
|
|
|
|
.macro magic_compare_and_branch w1 w2 label
|
|
/* Macro to compare registers w1 and w2 and conditionally branch to label. */
|
|
cmp \w1, \w2 /* Are w1 and w2 the same? */
|
|
magic_find_zero_bytes \w1
|
|
it eq
|
|
cmpeq ip, #0 /* Is there a zero byte in w1? */
|
|
bne \label
|
|
.endm /* magic_compare_and_branch */
|
|
|
|
.macro magic_find_zero_bytes w1
|
|
/* Macro to find all-zero bytes in w1, result is in ip. */
|
|
#if (defined (__ARM_FEATURE_DSP))
|
|
uadd8 ip, \w1, r6
|
|
sel ip, r7, r6
|
|
#else /* not defined (__ARM_FEATURE_DSP) */
|
|
/* __ARM_FEATURE_DSP is not defined for some Cortex-M processors.
|
|
Coincidently, these processors only have Thumb-2 mode, where we can use the
|
|
the (large) magic constant available directly as an immediate in instructions.
|
|
Note that we cannot use the magic constant in ARM mode, where we need
|
|
to create the constant in a register. */
|
|
sub ip, \w1, #0x01010101
|
|
bic ip, ip, \w1
|
|
and ip, ip, #0x80808080
|
|
#endif /* not defined (__ARM_FEATURE_DSP) */
|
|
.endm /* magic_find_zero_bytes */
|
|
|
|
.macro setup_return w1 w2
|
|
#ifdef __ARMEB__
|
|
mov r1, \w1
|
|
mov r2, \w2
|
|
#else /* not __ARMEB__ */
|
|
rev r1, \w1
|
|
rev r2, \w2
|
|
#endif /* not __ARMEB__ */
|
|
.endm /* setup_return */
|
|
|
|
/*
|
|
optpld r0, #0
|
|
optpld r1, #0
|
|
*/
|
|
|
|
/* Are both strings double-word aligned? */
|
|
orr ip, r0, r1
|
|
tst ip, #7
|
|
bne do_align
|
|
|
|
/* Fast path. */
|
|
init
|
|
|
|
doubleword_aligned:
|
|
|
|
/* Get here when the strings to compare are double-word aligned. */
|
|
/* Compare two words in every iteration. */
|
|
.p2align 2
|
|
2:
|
|
/*
|
|
optpld r0, #16
|
|
optpld r1, #16
|
|
*/
|
|
|
|
/* Load the next double-word from each string. */
|
|
ldrd r2, r3, [r0], #8
|
|
ldrd r4, r5, [r1], #8
|
|
|
|
magic_compare_and_branch w1=r2, w2=r4, label=return_24
|
|
magic_compare_and_branch w1=r3, w2=r5, label=return_35
|
|
b 2b
|
|
|
|
do_align:
|
|
/* Is the first string word-aligned? */
|
|
ands ip, r0, #3
|
|
beq word_aligned_r0
|
|
|
|
/* Fast compare byte by byte until the first string is word-aligned. */
|
|
/* The offset of r0 from a word boundary is in ip. Thus, the number of bytes
|
|
to read until the next word boudnary is 4-ip. */
|
|
bic r0, r0, #3
|
|
ldr r2, [r0], #4
|
|
lsls ip, ip, #31
|
|
beq byte2
|
|
bcs byte3
|
|
|
|
byte1:
|
|
ldrb ip, [r1], #1
|
|
uxtb r3, r2, ror #BYTE1_OFFSET
|
|
subs ip, r3, ip
|
|
bne fast_return
|
|
m_cbz reg=r3, label=fast_return
|
|
|
|
byte2:
|
|
ldrb ip, [r1], #1
|
|
uxtb r3, r2, ror #BYTE2_OFFSET
|
|
subs ip, r3, ip
|
|
bne fast_return
|
|
m_cbz reg=r3, label=fast_return
|
|
|
|
byte3:
|
|
ldrb ip, [r1], #1
|
|
uxtb r3, r2, ror #BYTE3_OFFSET
|
|
subs ip, r3, ip
|
|
bne fast_return
|
|
m_cbnz reg=r3, label=word_aligned_r0
|
|
|
|
fast_return:
|
|
mov r0, ip
|
|
bx lr
|
|
|
|
word_aligned_r0:
|
|
init
|
|
/* The first string is word-aligned. */
|
|
/* Is the second string word-aligned? */
|
|
ands ip, r1, #3
|
|
bne strcmp_unaligned
|
|
|
|
word_aligned:
|
|
/* The strings are word-aligned. */
|
|
/* Is the first string double-word aligned? */
|
|
tst r0, #4
|
|
beq doubleword_aligned_r0
|
|
|
|
/* If r0 is not double-word aligned yet, align it by loading
|
|
and comparing the next word from each string. */
|
|
ldr r2, [r0], #4
|
|
ldr r4, [r1], #4
|
|
magic_compare_and_branch w1=r2 w2=r4 label=return_24
|
|
|
|
doubleword_aligned_r0:
|
|
/* Get here when r0 is double-word aligned. */
|
|
/* Is r1 doubleword_aligned? */
|
|
tst r1, #4
|
|
beq doubleword_aligned
|
|
|
|
/* Get here when the strings to compare are word-aligned,
|
|
r0 is double-word aligned, but r1 is not double-word aligned. */
|
|
|
|
/* Initialize the queue. */
|
|
ldr r5, [r1], #4
|
|
|
|
/* Compare two words in every iteration. */
|
|
.p2align 2
|
|
3:
|
|
/*
|
|
optpld r0, #16
|
|
optpld r1, #16
|
|
*/
|
|
|
|
/* Load the next double-word from each string and compare. */
|
|
ldrd r2, r3, [r0], #8
|
|
magic_compare_and_branch w1=r2 w2=r5 label=return_25
|
|
ldrd r4, r5, [r1], #8
|
|
magic_compare_and_branch w1=r3 w2=r4 label=return_34
|
|
b 3b
|
|
|
|
.macro miscmp_word offsetlo offsethi
|
|
/* Macro to compare misaligned strings. */
|
|
/* r0, r1 are word-aligned, and at least one of the strings
|
|
is not double-word aligned. */
|
|
/* Compare one word in every loop iteration. */
|
|
/* OFFSETLO is the original bit-offset of r1 from a word-boundary,
|
|
OFFSETHI is 32 - OFFSETLO (i.e., offset from the next word). */
|
|
|
|
/* Initialize the shift queue. */
|
|
ldr r5, [r1], #4
|
|
|
|
/* Compare one word from each string in every loop iteration. */
|
|
.p2align 2
|
|
7:
|
|
ldr r3, [r0], #4
|
|
S2LOMEM r5, r5, #\offsetlo
|
|
magic_find_zero_bytes w1=r3
|
|
cmp r7, ip, S2HIMEM #\offsetlo
|
|
and r2, r3, r6, S2LOMEM #\offsetlo
|
|
it eq
|
|
cmpeq r2, r5
|
|
bne return_25
|
|
ldr r5, [r1], #4
|
|
cmp ip, #0
|
|
eor r3, r2, r3
|
|
S2HIMEM r2, r5, #\offsethi
|
|
it eq
|
|
cmpeq r3, r2
|
|
bne return_32
|
|
b 7b
|
|
.endm /* miscmp_word */
|
|
|
|
strcmp_unaligned:
|
|
/* r0 is word-aligned, r1 is at offset ip from a word. */
|
|
/* Align r1 to the (previous) word-boundary. */
|
|
bic r1, r1, #3
|
|
|
|
/* Unaligned comparison word by word using LDRs. */
|
|
cmp ip, #2
|
|
beq miscmp_word_16 /* If ip == 2. */
|
|
bge miscmp_word_24 /* If ip == 3. */
|
|
miscmp_word offsetlo=8 offsethi=24 /* If ip == 1. */
|
|
miscmp_word_16: miscmp_word offsetlo=16 offsethi=16
|
|
miscmp_word_24: miscmp_word offsetlo=24 offsethi=8
|
|
|
|
|
|
return_32:
|
|
setup_return w1=r3, w2=r2
|
|
b do_return
|
|
return_34:
|
|
setup_return w1=r3, w2=r4
|
|
b do_return
|
|
return_25:
|
|
setup_return w1=r2, w2=r5
|
|
b do_return
|
|
return_35:
|
|
setup_return w1=r3, w2=r5
|
|
b do_return
|
|
return_24:
|
|
setup_return w1=r2, w2=r4
|
|
|
|
do_return:
|
|
|
|
#ifdef __ARMEB__
|
|
mov r0, ip
|
|
#else /* not __ARMEB__ */
|
|
rev r0, ip
|
|
#endif /* not __ARMEB__ */
|
|
|
|
/* Restore temporaries early, before computing the return value. */
|
|
ldrd r6, r7, [sp]
|
|
ldrd r4, r5, [sp, #8]
|
|
adds sp, sp, #16
|
|
|
|
/* There is a zero or a different byte between r1 and r2. */
|
|
/* r0 contains a mask of all-zero bytes in r1. */
|
|
/* Using r0 and not ip here because cbz requires low register. */
|
|
m_cbz reg=r0, label=compute_return_value
|
|
clz r0, r0
|
|
/* r0 contains the number of bits on the left of the first all-zero byte in r1. */
|
|
rsb r0, r0, #24
|
|
/* Here, r0 contains the number of bits on the right of the first all-zero byte in r1. */
|
|
lsr r1, r1, r0
|
|
lsr r2, r2, r0
|
|
|
|
compute_return_value:
|
|
movs r0, #1
|
|
cmp r1, r2
|
|
/* The return value is computed as follows.
|
|
If r1>r2 then (C==1 and Z==0) and LS doesn't hold and r0 is #1 at return.
|
|
If r1<r2 then (C==0 and Z==0) and we execute SBC with carry_in=0,
|
|
which means r0:=r0-r0-1 and r0 is #-1 at return.
|
|
If r1=r2 then (C==1 and Z==1) and we execute SBC with carry_in=1,
|
|
which means r0:=r0-r0 and r0 is #0 at return.
|
|
(C==0 and Z==1) cannot happen because the carry bit is "not borrow". */
|
|
it ls
|
|
sbcls r0, r0, r0
|
|
bx lr
|
|
|
|
|
|
#else /* !(defined (_ISA_THUMB_2) || defined (_ISA_ARM_6)
|
|
defined (__OPTIMIZE_SIZE__) || defined (PREFER_SIZE_OVER_SPEED) ||
|
|
(defined (__thumb__) && !defined (__thumb2__))) */
|
|
|
|
/* Use LDR whenever possible. */
|
|
|
|
#ifdef __thumb2__
|
|
#define magic1(REG) 0x01010101
|
|
#define magic2(REG) 0x80808080
|
|
#else
|
|
#define magic1(REG) REG
|
|
#define magic2(REG) REG, lsl #7
|
|
#endif
|
|
|
|
optpld r0
|
|
optpld r1
|
|
eor r2, r0, r1
|
|
tst r2, #3
|
|
/* Strings not at same byte offset from a word boundary. */
|
|
bne strcmp_unaligned
|
|
ands r2, r0, #3
|
|
bic r0, r0, #3
|
|
bic r1, r1, #3
|
|
ldr ip, [r0], #4
|
|
it eq
|
|
ldreq r3, [r1], #4
|
|
beq 1f
|
|
/* Although s1 and s2 have identical initial alignment, they are
|
|
not currently word aligned. Rather than comparing bytes,
|
|
make sure that any bytes fetched from before the addressed
|
|
bytes are forced to 0xff. Then they will always compare
|
|
equal. */
|
|
eor r2, r2, #3
|
|
lsl r2, r2, #3
|
|
mvn r3, MSB
|
|
S2LOMEM r2, r3, r2
|
|
ldr r3, [r1], #4
|
|
orr ip, ip, r2
|
|
orr r3, r3, r2
|
|
1:
|
|
#ifndef __thumb2__
|
|
/* Load the 'magic' constant 0x01010101. */
|
|
str r4, [sp, #-4]!
|
|
mov r4, #1
|
|
orr r4, r4, r4, lsl #8
|
|
orr r4, r4, r4, lsl #16
|
|
#endif
|
|
.p2align 2
|
|
4:
|
|
optpld r0, #8
|
|
optpld r1, #8
|
|
sub r2, ip, magic1(r4)
|
|
cmp ip, r3
|
|
itttt eq
|
|
/* check for any zero bytes in first word */
|
|
biceq r2, r2, ip
|
|
tsteq r2, magic2(r4)
|
|
ldreq ip, [r0], #4
|
|
ldreq r3, [r1], #4
|
|
beq 4b
|
|
2:
|
|
/* There's a zero or a different byte in the word */
|
|
S2HIMEM r0, ip, #24
|
|
S2LOMEM ip, ip, #8
|
|
cmp r0, #1
|
|
it cs
|
|
cmpcs r0, r3, S2HIMEM #24
|
|
it eq
|
|
S2LOMEMEQ r3, r3, #8
|
|
beq 2b
|
|
/* On a big-endian machine, r0 contains the desired byte in bits
|
|
0-7; on a little-endian machine they are in bits 24-31. In
|
|
both cases the other bits in r0 are all zero. For r3 the
|
|
interesting byte is at the other end of the word, but the
|
|
other bits are not necessarily zero. We need a signed result
|
|
representing the differnece in the unsigned bytes, so for the
|
|
little-endian case we can't just shift the interesting bits
|
|
up. */
|
|
#ifdef __ARMEB__
|
|
sub r0, r0, r3, lsr #24
|
|
#else
|
|
and r3, r3, #255
|
|
#ifdef __thumb2__
|
|
/* No RSB instruction in Thumb2 */
|
|
lsr r0, r0, #24
|
|
sub r0, r0, r3
|
|
#else
|
|
rsb r0, r3, r0, lsr #24
|
|
#endif
|
|
#endif
|
|
#ifndef __thumb2__
|
|
ldr r4, [sp], #4
|
|
#endif
|
|
RETURN
|
|
|
|
|
|
strcmp_unaligned:
|
|
|
|
#if 0
|
|
/* The assembly code below is based on the following alogrithm. */
|
|
#ifdef __ARMEB__
|
|
#define RSHIFT <<
|
|
#define LSHIFT >>
|
|
#else
|
|
#define RSHIFT >>
|
|
#define LSHIFT <<
|
|
#endif
|
|
|
|
#define body(shift) \
|
|
mask = 0xffffffffU RSHIFT shift; \
|
|
w1 = *wp1++; \
|
|
w2 = *wp2++; \
|
|
do \
|
|
{ \
|
|
t1 = w1 & mask; \
|
|
if (__builtin_expect(t1 != w2 RSHIFT shift, 0)) \
|
|
{ \
|
|
w2 RSHIFT= shift; \
|
|
break; \
|
|
} \
|
|
if (__builtin_expect(((w1 - b1) & ~w1) & (b1 << 7), 0)) \
|
|
{ \
|
|
/* See comment in assembler below re syndrome on big-endian */\
|
|
if ((((w1 - b1) & ~w1) & (b1 << 7)) & mask) \
|
|
w2 RSHIFT= shift; \
|
|
else \
|
|
{ \
|
|
w2 = *wp2; \
|
|
t1 = w1 RSHIFT (32 - shift); \
|
|
w2 = (w2 LSHIFT (32 - shift)) RSHIFT (32 - shift); \
|
|
} \
|
|
break; \
|
|
} \
|
|
w2 = *wp2++; \
|
|
t1 ^= w1; \
|
|
if (__builtin_expect(t1 != w2 LSHIFT (32 - shift), 0)) \
|
|
{ \
|
|
t1 = w1 >> (32 - shift); \
|
|
w2 = (w2 << (32 - shift)) RSHIFT (32 - shift); \
|
|
break; \
|
|
} \
|
|
w1 = *wp1++; \
|
|
} while (1)
|
|
|
|
const unsigned* wp1;
|
|
const unsigned* wp2;
|
|
unsigned w1, w2;
|
|
unsigned mask;
|
|
unsigned shift;
|
|
unsigned b1 = 0x01010101;
|
|
char c1, c2;
|
|
unsigned t1;
|
|
|
|
while (((unsigned) s1) & 3)
|
|
{
|
|
c1 = *s1++;
|
|
c2 = *s2++;
|
|
if (c1 == 0 || c1 != c2)
|
|
return c1 - (int)c2;
|
|
}
|
|
wp1 = (unsigned*) (((unsigned)s1) & ~3);
|
|
wp2 = (unsigned*) (((unsigned)s2) & ~3);
|
|
t1 = ((unsigned) s2) & 3;
|
|
if (t1 == 1)
|
|
{
|
|
body(8);
|
|
}
|
|
else if (t1 == 2)
|
|
{
|
|
body(16);
|
|
}
|
|
else
|
|
{
|
|
body (24);
|
|
}
|
|
|
|
do
|
|
{
|
|
#ifdef __ARMEB__
|
|
c1 = (char) t1 >> 24;
|
|
c2 = (char) w2 >> 24;
|
|
#else /* not __ARMEB__ */
|
|
c1 = (char) t1;
|
|
c2 = (char) w2;
|
|
#endif /* not __ARMEB__ */
|
|
t1 RSHIFT= 8;
|
|
w2 RSHIFT= 8;
|
|
} while (c1 != 0 && c1 == c2);
|
|
return c1 - c2;
|
|
#endif /* 0 */
|
|
|
|
|
|
wp1 .req r0
|
|
wp2 .req r1
|
|
b1 .req r2
|
|
w1 .req r4
|
|
w2 .req r5
|
|
t1 .req ip
|
|
@ r3 is scratch
|
|
|
|
/* First of all, compare bytes until wp1(sp1) is word-aligned. */
|
|
1:
|
|
tst wp1, #3
|
|
beq 2f
|
|
ldrb r2, [wp1], #1
|
|
ldrb r3, [wp2], #1
|
|
cmp r2, #1
|
|
it cs
|
|
cmpcs r2, r3
|
|
beq 1b
|
|
sub r0, r2, r3
|
|
RETURN
|
|
|
|
2:
|
|
str r5, [sp, #-4]!
|
|
str r4, [sp, #-4]!
|
|
//stmfd sp!, {r4, r5}
|
|
mov b1, #1
|
|
orr b1, b1, b1, lsl #8
|
|
orr b1, b1, b1, lsl #16
|
|
|
|
and t1, wp2, #3
|
|
bic wp2, wp2, #3
|
|
ldr w1, [wp1], #4
|
|
ldr w2, [wp2], #4
|
|
cmp t1, #2
|
|
beq 2f
|
|
bhi 3f
|
|
|
|
/* Critical inner Loop: Block with 3 bytes initial overlap */
|
|
.p2align 2
|
|
1:
|
|
bic t1, w1, MSB
|
|
cmp t1, w2, S2LOMEM #8
|
|
sub r3, w1, b1
|
|
bic r3, r3, w1
|
|
bne 4f
|
|
ands r3, r3, b1, lsl #7
|
|
it eq
|
|
ldreq w2, [wp2], #4
|
|
bne 5f
|
|
eor t1, t1, w1
|
|
cmp t1, w2, S2HIMEM #24
|
|
bne 6f
|
|
ldr w1, [wp1], #4
|
|
b 1b
|
|
4:
|
|
S2LOMEM w2, w2, #8
|
|
b 8f
|
|
|
|
5:
|
|
#ifdef __ARMEB__
|
|
/* The syndrome value may contain false ones if the string ends
|
|
with the bytes 0x01 0x00 */
|
|
tst w1, #0xff000000
|
|
itt ne
|
|
tstne w1, #0x00ff0000
|
|
tstne w1, #0x0000ff00
|
|
beq 7f
|
|
#else
|
|
bics r3, r3, #0xff000000
|
|
bne 7f
|
|
#endif
|
|
ldrb w2, [wp2]
|
|
S2LOMEM t1, w1, #24
|
|
#ifdef __ARMEB__
|
|
lsl w2, w2, #24
|
|
#endif
|
|
b 8f
|
|
|
|
6:
|
|
S2LOMEM t1, w1, #24
|
|
and w2, w2, LSB
|
|
b 8f
|
|
|
|
/* Critical inner Loop: Block with 2 bytes initial overlap */
|
|
.p2align 2
|
|
2:
|
|
S2HIMEM t1, w1, #16
|
|
sub r3, w1, b1
|
|
S2LOMEM t1, t1, #16
|
|
bic r3, r3, w1
|
|
cmp t1, w2, S2LOMEM #16
|
|
bne 4f
|
|
ands r3, r3, b1, lsl #7
|
|
it eq
|
|
ldreq w2, [wp2], #4
|
|
bne 5f
|
|
eor t1, t1, w1
|
|
cmp t1, w2, S2HIMEM #16
|
|
bne 6f
|
|
ldr w1, [wp1], #4
|
|
b 2b
|
|
|
|
5:
|
|
#ifdef __ARMEB__
|
|
/* The syndrome value may contain false ones if the string ends
|
|
with the bytes 0x01 0x00 */
|
|
tst w1, #0xff000000
|
|
it ne
|
|
tstne w1, #0x00ff0000
|
|
beq 7f
|
|
#else
|
|
lsls r3, r3, #16
|
|
bne 7f
|
|
#endif
|
|
ldrh w2, [wp2]
|
|
S2LOMEM t1, w1, #16
|
|
#ifdef __ARMEB__
|
|
lsl w2, w2, #16
|
|
#endif
|
|
b 8f
|
|
|
|
6:
|
|
S2HIMEM w2, w2, #16
|
|
S2LOMEM t1, w1, #16
|
|
4:
|
|
S2LOMEM w2, w2, #16
|
|
b 8f
|
|
|
|
/* Critical inner Loop: Block with 1 byte initial overlap */
|
|
.p2align 2
|
|
3:
|
|
and t1, w1, LSB
|
|
cmp t1, w2, S2LOMEM #24
|
|
sub r3, w1, b1
|
|
bic r3, r3, w1
|
|
bne 4f
|
|
ands r3, r3, b1, lsl #7
|
|
it eq
|
|
ldreq w2, [wp2], #4
|
|
bne 5f
|
|
eor t1, t1, w1
|
|
cmp t1, w2, S2HIMEM #8
|
|
bne 6f
|
|
ldr w1, [wp1], #4
|
|
b 3b
|
|
4:
|
|
S2LOMEM w2, w2, #24
|
|
b 8f
|
|
5:
|
|
/* The syndrome value may contain false ones if the string ends
|
|
with the bytes 0x01 0x00 */
|
|
tst w1, LSB
|
|
beq 7f
|
|
ldr w2, [wp2], #4
|
|
6:
|
|
S2LOMEM t1, w1, #8
|
|
bic w2, w2, MSB
|
|
b 8f
|
|
7:
|
|
mov r0, #0
|
|
//ldmfd sp!, {r4, r5}
|
|
ldr r4, [sp], #4
|
|
ldr r5, [sp], #4
|
|
RETURN
|
|
8:
|
|
and r2, t1, LSB
|
|
and r0, w2, LSB
|
|
cmp r0, #1
|
|
it cs
|
|
cmpcs r0, r2
|
|
itt eq
|
|
S2LOMEMEQ t1, t1, #8
|
|
S2LOMEMEQ w2, w2, #8
|
|
beq 8b
|
|
sub r0, r2, r0
|
|
//ldmfd sp!, {r4, r5}
|
|
ldr r4, [sp], #4
|
|
ldr r5, [sp], #4
|
|
RETURN
|
|
|
|
#endif /* !(defined (_ISA_THUMB_2) || defined (_ISA_ARM_6)
|
|
defined (__OPTIMIZE_SIZE__) || defined (PREFER_SIZE_OVER_SPEED) ||
|
|
(defined (__thumb__) && !defined (__thumb2__))) */
|