让人看不懂的strcpy.c

imonyse

这是glibc6里面，strcpy.c的代码：

1. 
   
2. 01   char *
   
3. 02  strcpy (dest, src)
   
4. 03       char *dest;
   
5. 04       const char *src;
   
6. 05  {
   
7. 06    reg_char c;
   
8. 07    char *__unbounded s = (char *__unbounded) CHECK_BOUNDS_LOW (src);
   
9. 08    const ptrdiff_t off = CHECK_BOUNDS_LOW (dest) - s - 1;
   
10. 09    size_t n;
    
11. 10
    
12. 11     do
    
13. 12      {
    
14. 13        c = *s++;
    
15. 14        s[off] = c;
    
16. 15      }
    
17. 16    while (c != '\0');
    
18. 17
    
19. 18    n = s - src;
    
20. 19    (void) CHECK_BOUNDS_HIGH (src + n);
    
21. 20   (void) CHECK_BOUNDS_HIGH (dest + n);
    
22. 21
    
23. 22   return dest;
    
24. 23  }
    
25. 24 libc_hidden_builtin_def (strcpy)
    

复制代码

在bp-checks.h中定义有这2个宏：
/* Verify that pointer's value >= low.  Return pointer value.  */
# define CHECK_BOUNDS_LOW(ARG)                                  \
  (((__ptrvalue (ARG) < __ptrlow (ARG)) && BOUNDS_VIOLATED),    \
   __ptrvalue (ARG))

/* Verify that pointer's value < high.  Return pointer value.  */
# define CHECK_BOUNDS_HIGH(ARG)                         \
  (((__ptrvalue (ARG) > __ptrhigh (ARG)) && BOUNDS_VIOLATED),   \
   __ptrvalue (ARG))

cdefs.h文件中定义了这些宏
/* Support for bounded pointers.  */
#ifndef __BOUNDED_POINTERS__
# define __bounded      /* nothing */
# define __unbounded    /* nothing */
# define __ptrvalue     /* nothing */
#endif

我查看了一下bounded指针的涵义，貌似gcc不支持？所以优化过后的代码应该是：

1. 
   
2. 01   char *
   
3. 02  strcpy (char *dest, char *src)
   
4. 03  {
   
5. 04    register char c;
   
6. 05    const ptrdiff_t off = dest - src - 1;
   
7. 06
   
8. 07    do
   
9. 08      {
   
10. 09        c = *src++;
    
11. 10        src[off] = c;
    
12. 11       }
    
13. 12    while (c != '\0');
    
14. 13
    
15. 14   return dest;
    
16. 15  }
    

复制代码

我感到疑惑的是第05行，不是在一个数组里面的指针，减出来是什么？
很自然的
11     do
12      {
13        c = *src++;
14        src[off] = c;
15      }
16    while (c != '\0');
我也就看不懂了。

请大家指点迷津，在下有礼了...


更新一下，看来就是通过用src[off]代替dest作拷贝（觉得这里很取巧啊...让我想到了变长结构体）。如果c能成为一个寄存器变量，那么效率会比 *dest++ = *src++ 高吧。

看来早上学习效率真的不如下午啊...

[ 本帖最后由 imonyse 于 2007-11-21 13:20 编辑 ]

ldy2534

我猜是计算出 dest 和 src 在内存中的差值， 然后那个while 循环，是跟src这个内存地址 和off 这个差值找到dest。。

anthony1983

这样做和直接
  *dest++ = *src++
有效率上的区别么？？？

imonyse

看来就是通过用src[off]代替dest作拷贝。如果c能成为一个寄存器变量，那么效率会比 *dest++ = *src++ 高吧。

anthony1983

原帖由 imonyse 于 2007-11-21 13:15 发表
看来就是通过用src[off]代替dest作拷贝。如果c能成为一个寄存器变量，那么效率会比 *dest++ = *src++ 高吧。

我是问用src[off]来代替dest++操作有什么好处么，  至于c寄存器变量，也可以用在dest++上来

imonyse

就是效率吧
src[off]版的汇编片段：

1. 
   
2. my_strcpy:
   
3.         pushl   %ebp
   
4.         movl    %esp, %ebp
   
5.         subl    $16, %esp
   
6.         movl    8(%ebp), %edx
   
7.         movl    12(%ebp), %eax
   
8.         movl    %edx, %ecx
   
9.         subl    %eax, %ecx
   
10.         movl    %ecx, %eax
    
11.         subl    $1, %eax
    
12.         movl    %eax, -4(%ebp)
    
13. .L2:
    
14.         movl    12(%ebp), %eax
    
15.         movzbl  (%eax), %edx
    
16.         addl    $1, 12(%ebp)
    
17.         movl    -4(%ebp), %eax
    
18.         addl    12(%ebp), %eax
    
19.         movb    %dl, (%eax)
    
20.         testb   %dl, %dl
    
21.         jne     .L2
    
22.         movl    8(%ebp), %eax
    
23.         leave
    
24.         ret
    

复制代码

*dest＋＋＝*src++版的汇编:

1. 
   
2. my_strcpy:
   
3.         pushl   %ebp
   
4.         movl    %esp, %ebp
   
5.         jmp     .L2
   
6. .L3:
   
7.         movl    12(%ebp), %eax
   
8.         movzbl  (%eax), %edx
   
9.         movl    8(%ebp), %eax
   
10.         movb    %dl, (%eax)
    
11.         addl    $1, 8(%ebp)
    
12.         addl    $1, 12(%ebp)
    
13. .L2:
    
14.         cmpl    $0, 12(%ebp)
    
15.         jne     .L3
    
16.         movl    8(%ebp), %eax
    
17.         popl    %ebp
    
18.         ret
    

复制代码

编译器是gcc4.1
不是很懂汇编（以后再学...）

[ 本帖最后由 imonyse 于 2007-11-21 14:21 编辑 ]

~wind~

学习中

emacsnw

gnu的代码确实读起来比较费劲，还是喜欢FreeBSD的代码，简洁漂亮：

1. 
   
2. sys/libkern/strcpy.c
   
3. 
   
4. 35 char *
   
5. 36 strcpy(char * __restrict to, const char * __restrict from)
   
6. 37 {
   
7. 38         char *save = to;
   
8. 39
   
9. 40         for (; (*to = *from) != 0; ++from, ++to);
   
10. 41         return(save);
    
11. 42 }
    
12. 43
    

复制代码

prc

对比下面两个循环

while( (src[off] = *src++) != 0 )  ;
1. 从src表示的地址处读取数据
2. 将数据存放到src+off表示的地址处
3. src++
4. 判断取出的数是否为0，如果是0，则结束循环，否则继续执行1

while( (*dst++ = *src++) != 0 )   ;
1. 从src表示的地址处读取数据
2. 将数据存放到dst表示的地址处
3. src++
4. dst++
5. 判断取出的数是否为0，如果是0，则结束循环，否则继续执行1

x86 CPU可以通过
通用寄存器 + 2/4/8/16 * 通用寄存器 + 偏移
的方式寻址， 它和通过通用寄存器来寻址所耗费的周期是一样的，那么第一段代码比第二段代码在每次循环中少做一个++操作，从而获得更高的效率。

gaocheng

效率的话 ，感觉汇编最高~
REP MOVSB