AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-21 12:30:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

string: Improve generic memchr

Browse Source 
New algorithm read the first aligned address and mask off the
unwanted bytes (this strategy is similar to arch-specific
implementations used on powerpc, sparc, and sh).

The loop now read word-aligned address and check using the has_eq
macro.

Checked on x86_64-linux-gnu, i686-linux-gnu, powerpc-linux-gnu,
and powerpc64-linux-gnu by removing the arch-specific assembly
implementation and disabling multi-arch (it covers both LE and BE
for 64 and 32 bits).

Co-authored-by: Richard Henderson <richard.henderson@linaro.org>
Reviewed-by: Noah Goldstein <goldstein.w.n@gmail.com>
This commit is contained in:
Adhemerval Zanella 2023-01-10 18:00:59 -03:00
parent 3709ed9047
commit 2a8867a17f
3 changed files with 56 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
string/memchr.c
View File

@ -1,10 +1,6 @@
/* Copyright (C) 1991-2023 Free Software Foundation, Inc.
/* Scan memory for a character. Generic version
Copyright (C) 1991-2023 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Based on strlen implementation by Torbjorn Granlund (tege@sics.se),
with help from Dan Sahlin (dan@sics.se) and
commentary by Jim Blandy (jimb@ai.mit.edu);
adaptation to memchr suggested by Dick Karpinski (dick@cca.ucsf.edu),
and implemented by Roland McGrath (roland@ai.mit.edu).
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -20,143 +16,73 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#ifndef _LIBC
# include <config.h>
#endif
#include <libc-pointer-arith.h>
#include <string-fzb.h>
#include <string-fzc.h>
#include <string-fzi.h>
#include <string-shift.h>
#include <string.h>
#include <stddef.h>
#undef memchr
#include <limits.h>
#undef __memchr
#ifdef _LIBC
# undef memchr
#ifdef MEMCHR
# define __memchr MEMCHR
#endif
#ifndef weak_alias
# define __memchr memchr
#endif
#ifndef MEMCHR
# define MEMCHR __memchr
#endif
static __always_inline const char *
sadd (uintptr_t x, uintptr_t y)
{
return (const char *)(y > UINTPTR_MAX - x ? UINTPTR_MAX : x + y);
}
/* Search no more than N bytes of S for C. */
void *
MEMCHR (void const *s, int c_in, size_t n)
__memchr (void const *s, int c_in, size_t n)
{
/* On 32-bit hardware, choosing longword to be a 32-bit unsigned
long instead of a 64-bit uintmax_t tends to give better
performance. On 64-bit hardware, unsigned long is generally 64
bits already. Change this typedef to experiment with
performance. */
typedef unsigned long int longword;
if (__glibc_unlikely (n == 0))
return NULL;
const unsigned char *char_ptr;
const longword *longword_ptr;
longword repeated_one;
longword repeated_c;
unsigned char c;
/* Read the first word, but munge it so that bytes before the array
will not match goal. */
const op_t *word_ptr = PTR_ALIGN_DOWN (s, sizeof (op_t));
uintptr_t s_int = (uintptr_t) s;
c = (unsigned char) c_in;
op_t word = *word_ptr;
op_t repeated_c = repeat_bytes (c_in);
/* Compute the address of the last byte taking in consideration possible
overflow. */
const char *lbyte = sadd (s_int, n - 1);
/* And also the address of the word containing the last byte. */
const op_t *lword = (const op_t *) PTR_ALIGN_DOWN (lbyte, sizeof (op_t));
/* Handle the first few bytes by reading one byte at a time.
Do this until CHAR_PTR is aligned on a longword boundary. */
for (char_ptr = (const unsigned char *) s;
n > 0 && (size_t) char_ptr % sizeof (longword) != 0;
--n, ++char_ptr)
if (*char_ptr == c)
return (void *) char_ptr;
longword_ptr = (const longword *) char_ptr;
/* All these elucidatory comments refer to 4-byte longwords,
but the theory applies equally well to any size longwords. */
/* Compute auxiliary longword values:
repeated_one is a value which has a 1 in every byte.
repeated_c has c in every byte. */
repeated_one = 0x01010101;
repeated_c = c | (c << 8);
repeated_c |= repeated_c << 16;
if (0xffffffffU < (longword) -1)
find_t mask = shift_find (find_eq_all (word, repeated_c), s_int);
if (mask != 0)
{
repeated_one |= repeated_one << 31 << 1;
repeated_c |= repeated_c << 31 << 1;
if (8 < sizeof (longword))
{
size_t i;
char *ret = (char *) s + index_first (mask);
return (ret <= lbyte) ? ret : NULL;
}
if (word_ptr == lword)
return NULL;
for (i = 64; i < sizeof (longword) * 8; i *= 2)
{
repeated_one |= repeated_one << i;
repeated_c |= repeated_c << i;
}
}
word = *++word_ptr;
while (word_ptr != lword)
{
if (has_eq (word, repeated_c))
return (char *) word_ptr + index_first_eq (word, repeated_c);
word = *++word_ptr;
}
/* Instead of the traditional loop which tests each byte, we will test a
longword at a time. The tricky part is testing if *any of the four*
bytes in the longword in question are equal to c. We first use an xor
with repeated_c. This reduces the task to testing whether *any of the
four* bytes in longword1 is zero.
We compute tmp =
((longword1 - repeated_one) & ~longword1) & (repeated_one << 7).
That is, we perform the following operations:
1. Subtract repeated_one.
2. & ~longword1.
3. & a mask consisting of 0x80 in every byte.
Consider what happens in each byte:
- If a byte of longword1 is zero, step 1 and 2 transform it into 0xff,
and step 3 transforms it into 0x80. A carry can also be propagated
to more significant bytes.
- If a byte of longword1 is nonzero, let its lowest 1 bit be at
position k (0 <= k <= 7); so the lowest k bits are 0. After step 1,
the byte ends in a single bit of value 0 and k bits of value 1.
After step 2, the result is just k bits of value 1: 2^k - 1. After
step 3, the result is 0. And no carry is produced.
So, if longword1 has only non-zero bytes, tmp is zero.
Whereas if longword1 has a zero byte, call j the position of the least
significant zero byte. Then the result has a zero at positions 0, ...,
j-1 and a 0x80 at position j. We cannot predict the result at the more
significant bytes (positions j+1..3), but it does not matter since we
already have a non-zero bit at position 8*j+7.
So, the test whether any byte in longword1 is zero is equivalent to
testing whether tmp is nonzero. */
while (n >= sizeof (longword))
if (has_eq (word, repeated_c))
{
longword longword1 = *longword_ptr ^ repeated_c;
if ((((longword1 - repeated_one) & ~longword1)
& (repeated_one << 7)) != 0)
break;
longword_ptr++;
n -= sizeof (longword);
/* We found a match, but it might be in a byte past the end of the
array. */
char *ret = (char *) word_ptr + index_first_eq (word, repeated_c);
if (ret <= lbyte)
return ret;
}
char_ptr = (const unsigned char *) longword_ptr;
/* At this point, we know that either n < sizeof (longword), or one of the
sizeof (longword) bytes starting at char_ptr is == c. On little-endian
machines, we could determine the first such byte without any further
memory accesses, just by looking at the tmp result from the last loop
iteration. But this does not work on big-endian machines. Choose code
that works in both cases. */
for (; n > 0; --n, ++char_ptr)
{
if (*char_ptr == c)
return (void *) char_ptr;
}
return NULL;
}
#ifdef weak_alias
#ifndef MEMCHR
weak_alias (__memchr, memchr)
#endif
libc_hidden_builtin_def (memchr)
#endif

16
sysdeps/powerpc/powerpc32/power4/multiarch/memchr-ppc32.c
View File

@ -18,17 +18,11 @@
#include <string.h>
#define MEMCHR __memchr_ppc
#undef weak_alias
#define weak_alias(a, b)
#ifdef SHARED
# undef libc_hidden_builtin_def
# define libc_hidden_builtin_def(name) \
__hidden_ver1(__memchr_ppc, __GI_memchr, __memchr_ppc);
#endif
extern __typeof (memchr) __memchr_ppc attribute_hidden;
#define MEMCHR __memchr_ppc
#include <string/memchr.c>
#ifdef SHARED
__hidden_ver1(__memchr_ppc, __GI_memchr, __memchr_ppc);
#endif

9
sysdeps/powerpc/powerpc64/multiarch/memchr-ppc64.c
View File

@ -18,14 +18,7 @@
#include <string.h>
#define MEMCHR __memchr_ppc
#undef weak_alias
#define weak_alias(a, b)
# undef libc_hidden_builtin_def
# define libc_hidden_builtin_def(name)
extern __typeof (memchr) __memchr_ppc attribute_hidden;
#define MEMCHR __memchr_ppc
#include <string/memchr.c>