glibc-2.19 之 strlen 实现

前几天遇到一个有意思的问题，实现strlen 不考虑线程安全:

下面是我的实现:

 size_t strlen(const char* s)
 {
     const char* p = s;
     while (*p++);
     return p--s;
 }

Glibc 2.19 的实现:
针对此实现，函数头部分没太明白， size_t strlen (str) const char *str; 详细情况参见Glibc 2.19, 下面的实现还是比较经典的兼顾性能和体系机构。

 /* 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) - )) != ;
        ++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) > )
     {
       /* 64-bit version of the magic.  */
       /* Do the shift in two steps to avoid a warning if long has 32 bits.  */
       himagic = ((himagic << ) << ) | himagic;
       lomagic = ((lomagic << ) << ) | lomagic;
     }
   if (sizeof (longword) > )
     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) != )
     {
       /* 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 - );

       if (cp[] == )
         return cp - str;
       if (cp[] == )
         return cp - str + ;
       if (cp[] == )
         return cp - str + ;
       if (cp[] == )
         return cp - str + ;
       if (sizeof (longword) > )
         {
           if (cp[] == )
         return cp - str + ;
           if (cp[] == )
         return cp - str + ;
           if (cp[] == )
         return cp - str + ;
           if (cp[] == )
         return cp - str + ;
         }
     }
     }
 }