| /* Copyright (C) 1991-2014 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| Written by Torbjorn Granlund (tege@sics.se), |
| with help from Dan Sahlin (dan@sics.se); |
| commentary by Jim Blandy (jimb@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 |
| 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/>. */ |
| |
| #include <string.h> |
| #include <stdlib.h> |
| |
| #undef strlen |
| |
| /* Return the length of the null-terminated string STR. Scan for |
| the null terminator quickly by testing four bytes at a time. */ |
| size_t |
| strlen (str) |
| const char *str; |
| { |
| const char *char_ptr; |
| const unsigned long int *longword_ptr; |
| unsigned long int longword, himagic, lomagic; |
| |
| /* 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) |
| if (*char_ptr == '\0') |
| return char_ptr - str; |
| |
| /* 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 = *longword_ptr++; |
| |
| 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); |
| |
| 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; |
| } |
| } |
| } |
| } |
| libc_hidden_builtin_def (strlen) |
