@@ -20,6 +20,9 @@
#include <string.h>
#include <stdlib.h>
+#include <stdint.h>
+#include <haszero.h>
+#include <whichzero.h>
#undef strlen
@@ -32,78 +35,29 @@
size_t
STRLEN (const char *str)
{
- const char *char_ptr;
+ const char *char_ptr = str;
const unsigned long int *longword_ptr;
- unsigned long int longword, himagic, lomagic;
+ unsigned long int longword;
+ uintptr_t i, align;
/* Handle the first few characters by reading one character at a time.
Do this until CHAR_PTR is aligned on a longword boundary. */
- for (char_ptr = str; ((unsigned long int) char_ptr
- & (sizeof (longword) - 1)) != 0;
- ++char_ptr)
+ align = -(uintptr_t)char_ptr % sizeof(longword);
+ for (i = 0; i < align; ++i, ++char_ptr)
if (*char_ptr == '\0')
- return char_ptr - str;
+ goto found;
- /* All these elucidatory comments refer to 4-byte longwords,
- but the theory applies equally well to 8-byte longwords. */
-
- longword_ptr = (unsigned long int *) char_ptr;
-
- /* Bits 31, 24, 16, and 8 of this number are zero. Call these bits
- the "holes." Note that there is a hole just to the left of
- each byte, with an extra at the end:
-
- bits: 01111110 11111110 11111110 11111111
- bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD
-
- The 1-bits make sure that carries propagate to the next 0-bit.
- The 0-bits provide holes for carries to fall into. */
- himagic = 0x80808080L;
- lomagic = 0x01010101L;
- if (sizeof (longword) > 4)
- {
- /* 64-bit version of the magic. */
- /* Do the shift in two steps to avoid a warning if long has 32 bits. */
- himagic = ((himagic << 16) << 16) | himagic;
- lomagic = ((lomagic << 16) << 16) | lomagic;
- }
- if (sizeof (longword) > 8)
- abort ();
-
- /* Instead of the traditional loop which tests each character,
- 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 zero. */
- for (;;)
+ longword_ptr = (const unsigned long int *) char_ptr;
+ do
{
longword = *longword_ptr++;
+ }
+ while (!haszero(longword));
- if (((longword - lomagic) & ~longword & himagic) != 0)
- {
- /* Which of the bytes was the zero? If none of them were, it was
- a misfire; continue the search. */
-
- const char *cp = (const char *) (longword_ptr - 1);
+ char_ptr = (const char *) (longword_ptr - 1);
+ char_ptr += whichzero(longword);
- if (cp[0] == 0)
- return cp - str;
- if (cp[1] == 0)
- return cp - str + 1;
- if (cp[2] == 0)
- return cp - str + 2;
- if (cp[3] == 0)
- return cp - str + 3;
- if (sizeof (longword) > 4)
- {
- if (cp[4] == 0)
- return cp - str + 4;
- if (cp[5] == 0)
- return cp - str + 5;
- if (cp[6] == 0)
- return cp - str + 6;
- if (cp[7] == 0)
- return cp - str + 7;
- }
- }
- }
+ found:
+ return char_ptr - str;
}
libc_hidden_builtin_def (strlen)
new file mode 100644
@@ -0,0 +1,34 @@
+/* extractbyte.h -- function memory order byte extract. Generic C version.
+ Copyright (C) 2016 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef EXTRACTBYTE_H
+#define EXTRACTBYTE_H 1
+
+#include <limits.h>
+#include <endian.h>
+
+static inline unsigned char
+extractbyte(unsigned long int x, unsigned idx)
+{
+ if (__BYTE_ORDER == __LITTLE_ENDIAN)
+ return x >> (idx * CHAR_BIT);
+ else
+ return x >> (sizeof(x) - 1 - idx) * CHAR_BIT;
+}
+
+#endif /* EXTRACTBYTE_H */
new file mode 100644
@@ -0,0 +1,42 @@
+/* haszero.h -- function for zero byte detection. Generic C version.
+ Copyright (C) 2016 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef HASZERO_H
+#define HASZERO_H 1
+
+/* See https://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord */
+
+static inline unsigned long int
+haszero(unsigned long int x)
+{
+ unsigned long int ones = -1UL / 0xff;
+ unsigned long int signs = ones * 0x80;
+ return (x - ones) & ~x & signs;
+}
+
+/* Likewise, but for two words simultaneously. */
+
+static inline unsigned long int
+haszero2(unsigned long int x1, unsigned long int x2)
+{
+ unsigned long int ones = -1UL / 0xff;
+ unsigned long int signs = ones * 0x80;
+ return (((x1 - ones) & ~x1) | ((x2 - ones) & ~x2)) & signs;
+}
+
+#endif /* haszero.h */
new file mode 100644
@@ -0,0 +1,67 @@
+/* whichzero.h -- functions for zero byte searching. Generic C version.
+ Copyright (C) 2016 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef WHICHZERO_H
+#define WHICHZERO_H 1
+
+#include <endian.h>
+
+/* A subroutine for the whichzero and whichzero2 functions. Given a
+ test word C, return the index of the first byte in memory order
+ that contains 0x80 (all other bits will be zero). */
+
+static inline unsigned int
+whichzero_ffs(unsigned long int c)
+{
+ if (__BYTE_ORDER == __LITTLE_ENDIAN)
+ return __builtin_ctzl (c) / 8u;
+ else
+ return __builtin_clzl (c) / 8u;
+}
+
+/* Given a long that is known to contain a zero byte, return the
+ index of the first such within the long in host memory order. */
+
+static inline unsigned int
+whichzero(unsigned long int x)
+{
+ /* For each byte, find not-zero by
+ (0) And 0x7f so that we cannot carry between bytes,
+ (1) Add 0x7f so that we carry into 0x80,
+ (2) Or in the original byte which might have contained 0x80.
+ Then invert and mask such that 0x80 is set iff the byte was zero. */
+ unsigned long int m = (-1UL / 0xff) * 0x7f;
+ unsigned long int c = ~(((x & m) + m) | x | m);
+
+ return whichzero_ffs(c);
+}
+
+/* Similarly, but perform the test for two longs simultaneously. */
+
+static inline unsigned int
+whichzero2(unsigned long int x1, unsigned long int x2)
+{
+ unsigned long int m = (-1UL / 0xff) * 0x7f;
+ unsigned long int c1 = ((x1 & m) + m) | x1;
+ unsigned long int c2 = ((x2 & m) + m) | x2;
+ unsigned long int c = ~((c1 & c2) | m);
+
+ return whichzero_ffs(c);
+}
+
+#endif /* whichzero.h */