【glibC阅读】之 strlen实现

辛昕

【glibC阅读】之 strlen实现 [复制链接]

写在前面的话：
        其实不管是 strlen的实现，甚至是glibc的实现，对我来说其实都不是什么有多大实际价值的事情。我只是意识到，如果我真的要学会阅读代码，我必须真的去尝试阅读代码。
        而选择glibc，是因为它是一个通用的标准库，而且与我常年使用C有密切关系。
        这个帖子的内容，对于那些早已经熟悉这些套路的人（x86汇编和gcc大神）来说，简直小儿科到不足一提。
        不过，我相信对于大多数和我这样，对此几乎一窍不通的小白来说，这个过程本身是很有参考价值的。而我写下这个过程，本身也是为我逐渐积累阅读较大型代码库的能力和经验做准备。希望没有破坏什么人的雅兴和胃口。    

        此前发的帖子，那个strlen的glibc实现分析，太监了很久。周末用了所剩不多的零碎时间，尝试阅读一下。
当然现在也还是不十分明白，但是，先做个记录。

        环境说明：
        1.我用的glibC 源码版本是 2.14
        2.我用的souce insight阅读——否则我接下来叙述的内容，有可能出现部分名词不一致，可能影响理解。

        阅读方式：
        由于我仍然未能理解glibc的项目源码结构，所以我尚不能跑起任何一个小程序exe,我仅仅从代码的依赖关系上去分析。
我的分析起点正是   对 strlen() 邮件 go to definition......

辛昕

找下来，总共有四处定义——我不得不说，对于第一次阅读比较大的库的我来说，这是个下马威。

硬着头皮看，其中两处为 .c源文件，两处为.h头文件，以至于我以为两个是宏定义，但后来看并非如此，而是 内联函数。

内联函数在cpp里我见得比较多，但在C里实际上见的不多，因为很多时候，IAR也好，MDK也好，都无法使用。

闲话少说，以下四楼，分别列出。

辛昕

// 我根据自己喜欢的代码格式，做了一些很细微的调整，但未动一个字母。

1. // 1 strlen - Function in Strlen.c (sysdeps\i386) at line 23 (13 lines)
   
2. #include <string.h>
   
3. 
   
4. size_t strlen (const char *str)
   
5. {
   
6.   int cnt;
   
7. 
   
8.   asm(       "cld\n"                        /* Search forward.  */
   
9.                                         /* Some old versions of gas need `repne' instead of `repnz'.  */
   
10.       "repnz\n"                     /* Look for a zero byte.  */
    
11.       "scasb" /* %0, %1, %3 */ :
    
12.       "=c" (cnt) : "D" (str), "0" (-1), "a" (0));
    
13. 
    
14.        return -2 - cnt;
    
15. }
    
16. libc_hidden_builtin_def (strlen)
    
17. 
    
18. // 这段代码，显然是针对x86的实现，一堆asm，鬼看得懂，也不在意，在意的是 最后一句，是什么意思
    
19. // 同时好奇的是，那其他几个实现是怎么回事

复制代码

辛昕

1. //        *这个文件位于 根目录下 string/strlen.c
   
2. //2 strlen - Function in Strlen.c (string) at line 29 (78 lines)
   
3. #include <string.h>
   
4. #include <stdlib.h>
   
5.         
   
6. #undef strlen                                        // 标注1
   
7. 
   
8. /* Return the length of the null-terminated string STR.  Scan for
   
9.    the null terminator quickly by testing four bytes at a time.  */
   
10. size_t strlen (str) const char *str;
    
11. {
    
12.   const char *char_ptr;
    
13.   const unsigned long int *longword_ptr;
    
14.   unsigned long int longword, himagic, lomagic;
    
15. 
    
16.   /* Handle the first few characters by reading one character at a time.
    
17.      Do this until CHAR_PTR is aligned on a longword boundary.  */
    
18.   for (char_ptr = str; ((unsigned long int) char_ptr
    
19.                         & (sizeof (longword) - 1)) != 0;
    
20.        ++char_ptr)
    
21.     if (*char_ptr == '\0')
    
22.       return char_ptr - str;
    
23. 
    
24.   /* All these elucidatory comments refer to 4-byte longwords,
    
25.      but the theory applies equally well to 8-byte longwords.  */
    
26. 
    
27.   longword_ptr = (unsigned long int *) char_ptr;
    
28. 
    
29.   /* Bits 31, 24, 16, and 8 of this number are zero.  Call these bits
    
30.      the "holes."  Note that there is a hole just to the left of
    
31.      each byte, with an extra at the end:
    
32. 
    
33.      bits:  01111110 11111110 11111110 11111111
    
34.      bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD
    
35. 
    
36.      The 1-bits make sure that carries propagate to the next 0-bit.
    
37.      The 0-bits provide holes for carries to fall into.  */
    
38.   himagic = 0x80808080L;
    
39.   lomagic = 0x01010101L;
    
40.   if (sizeof (longword) > 4)
    
41.     {
    
42.       /* 64-bit version of the magic.  */
    
43.       /* Do the shift in two steps to avoid a warning if long has 32 bits.  */
    
44.       himagic = ((himagic << 16) << 16) | himagic;
    
45.       lomagic = ((lomagic << 16) << 16) | lomagic;
    
46.     }
    
47.   if (sizeof (longword) > 8)
    
48.     abort ();
    
49. 
    
50.   /* Instead of the traditional loop which tests each character,
    
51.      we will test a longword at a time.  The tricky part is testing
    
52.      if *any of the four* bytes in the longword in question are zero.  */
    
53.   for (;;)
    
54.     {
    
55.       longword = *longword_ptr++;
    
56. 
    
57.       if (((longword - lomagic) & ~longword & himagic) != 0)
    
58.         {
    
59.           /* Which of the bytes was the zero?  If none of them were, it was
    
60.              a misfire; continue the search.  */
    
61. 
    
62.           const char *cp = (const char *) (longword_ptr - 1);
    
63. 
    
64.           if (cp[0] == 0)
    
65.             return cp - str;
    
66.           if (cp[1] == 0)
    
67.             return cp - str + 1;
    
68.           if (cp[2] == 0)
    
69.             return cp - str + 2;
    
70.           if (cp[3] == 0)
    
71.             return cp - str + 3;
    
72.           if (sizeof (longword) > 4)
    
73.             {
    
74.               if (cp[4] == 0)
    
75.                 return cp - str + 4;
    
76.               if (cp[5] == 0)
    
77.                 return cp - str + 5;
    
78.               if (cp[6] == 0)
    
79.                 return cp - str + 6;
    
80.               if (cp[7] == 0)
    
81.                 return cp - str + 7;
    
82.             }
    
83.         }
    
84.     }
    
85. }
    
86. libc_hidden_builtin_def (strlen)
    
87. 
    
88. // 这是一段看起来完全与平台无关的代码。似乎可以认为是我们追踪的终点。
    
89. // 我唯一有点好奇，相信也是你们好奇的，为什么，我们可以用区区几行代码实现的 strlen() 在这里居然这么复杂！
    
90. // 另外，见标注1：这是在干什么？
    
91. // 它要取消前面的（宏）定义 strlen,所以几乎可以料想，还有两个 strlen 的 宏定义（不要被小写迷惑了？）
    
92. 
    

复制代码

辛昕

//3 strlen - Macro in String.h (sysdeps\s390\bits) at line 43
        // 这段预警告似乎在暗示我们，这个定义是一个替代定义。

1. #ifndef _STRING_H
   
2. # error "Never use <bits/string.h> directly; include <string.h> instead."
   
3. #endif

复制代码

// 紧随其后的是一个 strlen 的实现版本

1. #ifndef _FORCE_INLINES
   
2. #define strlen(str) __strlen_g ((str))
   
3. 
   
4. __STRING_INLINE size_t __strlen_g (__const char *) __asm__ ("strlen");
   
5. // 这段代码的解释：
   
6. // __STRING_INLINE 这个没什么，搜索可以看到，它可能有三种定义：1.啥都没；2.inline;3.extern inline
   
7. // 虽然我并不理解C下的 内联函数是怎么回事，但内联就只是内联而已，没什么特别的。
   
8. // 至于 extern inline 我的确并不确切理解这个 外部是个什么鬼，但不管如何，也就只是个内联，在
   
9. // 这次的阅读里，我真心丝毫不关心。

复制代码

1. // __asm__ 倒是一个知识点，不过，也没什么特别，它是gcc的一个关键字，意思是接下来要使用汇编代码了。
   
2. // 我还是不明白的是， 后面跟着一个 ("strlen")  这是个什么操作？
   
3. 
   
4. // 百度到一个这样的东西，让我领悟到 这个 内嵌 asm 的语法
   
5. /*
   
6.         __asm__("mov r0, #0\n"}
   
7. */
   
8. 
   
9. // 所以上述的 这句话，其实大概率翻译成常见的形式就会是
   
10. 
    
11. /*
    
12.         inline size_t __strlen_g (__const char *)
    
13.         {
    
14.                 __asm__ ("strlen");        
    
15.         }
    
16.         
    
17.         我并不明白这个地方为毛这么该死非要挤在一行上看，但显然，至少对于我，这样的格式我更容易看懂
    
18.         我可以理解在汇编里出现 mov 之类的语句，
    
19.         但出现一个 strlen 我是理解不了的。
    
20. */
    

复制代码

1. __STRING_INLINE size_t __strlen_g (__const char *__str)
   
2. {
   
3.     char *__ptr, *__tmp;
   
4. 
   
5.     __ptr = (char *) 0;
   
6.     __tmp = (char *) __str;
   
7.     __asm__ __volatile__ ("   la    0,0\n"
   
8.                           "0: srst  %0,%1\n"
   
9.                           "   jo    0b\n"
   
10.                           : "+&a" (__ptr), "+&a" (__tmp) :
    
11.                           : "cc", "memory", "0" );
    
12.     return (size_t) (__ptr - __str);
    
13. }
    
14. 
    
15. // 这一段对我来说倒没什么太特别的，无非就是一堆x86汇编代码，我看不懂，但反正就是在干strlen该干的事的意思
    
16. #endif

复制代码

辛昕

1. // 先看最后一处 strlen 宏定义
   
2. //4 strlen - Macro in String.h (sysdeps\i386\i486\bits) at line 549 (4 lines)
   
3. /* Return the length of S.  */
   
4. #define _HAVE_STRING_ARCH_strlen 1
   
5. #define strlen(str) \
   
6.   (__extension__ (__builtin_constant_p (str)                                      \
   
7.                   ? __builtin_strlen (str)                                      \
   
8.                   : __strlen_g (str)))
   
9.                   
   
10.                         // 标注2
    
11. __STRING_INLINE size_t __strlen_g (__const char *__str);
    
12. 
    
13. __STRING_INLINE size_t
    
14. __strlen_g (__const char *__str)
    
15. {
    
16.   register char __dummy;
    
17.   register __const char *__tmp = __str;
    
18.   __asm__ __volatile__
    
19.     ("1:\n\t"
    
20.      "movb        (%0),%b1\n\t"
    
21.      "leal        1(%0),%0\n\t"
    
22.      "testb        %b1,%b1\n\t"
    
23.      "jne        1b"
    
24.      : "=r" (__tmp), "=&q" (__dummy)
    
25.      : "0" (__str),
    
26.        "m" ( *(struct { char __x[0xfffffff]; } *)__str)
    
27.      : "cc" );
    
28.   return __tmp - __str - 1;
    
29. }
    
30. 
    
31. /*
    
32.         总体而言，这是一个和 第三处，其实十分相似的结构。
    
33.         唯一要理解的是一个新的语法团——标注2
    
34.        
    
35. */

复制代码

辛昕

我最终意识到，要真的继续玩下去。
除了去挖那些很可能是 x86汇编语法 或者是 gcc 语法。

否则，真的不知道这一个小小的strlen都能给我闹出4个定义，我鬼知道你最后到底用的是哪个定义啊？
彼此又是什么关系，又为毛要搞得这么复杂？

这些都是接下去要尝试做的事情。