title: Understanding code in strlen implementation
body: <p>I have two questions regarding the implementation of <code>strlen</code> in <code>string.h</code> in glibc.</p>
  
  <ol>
  <li><p>The implementation uses a magic number with 'holes'. I am not able to understand how this works. Can someone please help me understand this snippet: </p>
  
  <pre><code>size_t
  strlen (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
               &amp; (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) &gt; 4)
         {
             /* 64-bit version of the magic.  */
             /* Do the shift in two steps to avoid a warning if long has 32 bits.  */
             himagic = ((himagic &lt;&lt; 16) &lt;&lt; 16) | himagic;
               lomagic = ((lomagic &lt;&lt; 16) &lt;&lt; 16) | lomagic;
           }
         if (sizeof (longword) &gt; 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) &amp; ~longword &amp; 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) &gt; 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;
  }}}
  </code></pre>
  
  <p>What is the magic number being used for?</p></li>
  <li><p>Why not simply increment pointer until NULL character and return count? Is this approach faster? Why is it so?</p></li>
  </ol>