x86 下 strcpy 高效实现

0. 先看个通常的实现：

为了分析方便不考虑 to/from 指针为NULL情况。

char *strcpy(char *to, const char *from)
{
    char *rev = to;
    while(*to++ = *from++);
    return rev;
}


gcc -S test.c -o test.s 编译产生汇编码为：

strcpy:                                 # ebp + 8 处为to, ebp + 12 处为from, ebp + 16 ...
  pushl   %ebp
  movl   %esp, %ebp
  subl   $16, %esp               # 在栈上为局部变量分配空间
  movl   8(%ebp), %eax         # 参数to 置入 eax
  movl   %eax, -4(%ebp)         # ebp - 4 处为 rev 所在

.L6:
  movl   12(%ebp), %eax         # 参数 from 置入 eax
  movzbl (%eax), %edx        
  movl   8(%ebp), %eax
  movb   %dl, (%eax)
  movl   8(%ebp), %eax
  movzbl (%eax), %eax
  testb   %al, %al
  setne   %dl
  incl   8(%ebp)                   # to 增1, 对应 to++
  leal   12(%ebp), %eax
  incl   (%eax)                   # from 增1, 对应 from++
  testb   %dl, %dl
  jne .L6

  movl   -4(%ebp), %eax         # return rev
  leave
  ret

可以看到实现拷贝的操作由 .L6 到 jne .L6 之间操作完成。显然这个实现是很臭的。



1. 编译器优化

现用 -O 参数重新编译： gcc -O -S test.c -o test.s

汇编码为：

strcpy:
  pushl   %ebp
  movl   %esp, %ebp
  pushl   %ebx
  movl   8(%ebp), %ebx         # 参数 to 置入 ebx
  movl   12(%ebp), %ecx         # 参数 from 置入 ecx
  movl   %ebx, %edx              

.L6:
  movzbl (%ecx), %eax
  movb   %al, (%edx)
  incl   %edx
  incl   %ecx
  testb   %al, %al
  jne .L6

  movl   %ebx, %eax               # return rev
  popl   %ebx
  popl   %ebp
  ret

可以看到经过优化后的代码，实现拷贝的循环操作效率得到大幅的提高，且使用寄存器 ebx
作临时变量 rev 的所在，这比将 rev 存储于内存中要快得多。



2. 内核与glibc的实现

位于 [include/asm-i386/string.h]

inline char * strcpy(char * dest,const char *src)
{
    int d0, d1, d2;
    __asm__ __volatile__(
        "1:/tlodsb/n/t"
        "stosb/n/t"
        "testb %%al,%%al/n/t"
        "jne 1b"
        : "=&S" (d0), "=&D" (d1), "=&a" (d2)     # 此为输出节，意为将寄存器的值
                                                        # 传给变量，参看下面的汇编码

        : "0" (src), "1" (dest)                   # 此处为输入节，意为将变量的值
                                                        # 传给对应寄存器
        : "memory");
    return dest;
}


在strcpy 中直接嵌入 x86 的串操作指令： lodsb, stosb。


gcc -S test.c -o test.s 产生的汇编码为：

strcpy:
    ...
  movl   8(%ebp), %edi         # 对应输入节，dest ---> edi
  movl   12(%ebp), %esi         # src ----> esi

  cld
1:
  lodsb                             # al   <--- [esi]
  stosb                             # [edi] <--- al
  testb %al, %al                   # al 为 '/0' 时循环结束
  jnz 1b

  movl   %esi, -20(%ebp)         # 此处对应输出节, ebp-20 处为 d0
  movl   %edi, -16(%ebp)         # ebp-16 处为 d1
  movl   %eax, -12(%ebp)         # ebp-12 处为 d2
  movl   8(%ebp), %eax         # return dest
    ...
  ret

上面对应输出节的三条movl指令没有实际作用，可以加 -O 参数编译器会将其优化掉。


至于核心中strcpy的实现为何要引入 d0, d1, d2 这三个变量，请看下面的实现：

inline char * strcpy(char * dest,const char *src)
{
  asm volatile
    (
        "cld/n"
        "1:/n/t"
        "lodsb/n/t"
        "stosb/n/t"
        "testb %%al, %%al/n/t"
        "jnz 1b/n/t"
        :
        : "S"(from), "D"(to)
        : "memory"
    );

  return to;
}


在不加 -O 参数的情况下是可以正常工作的，但如果加了 -O 则:

....
  cld
1:
  lodsb
  stosb
  testb %al, %al
  jnz 1b

  movl   %edi, %eax         # error, 返回值出错，此时edi已经指向字符串尾了
....
  ret


可以看到引入 d0, d1, d2 的作用，实际上是一个局部保存的作用，旨在不改变实参的值。


有关 gcc 的内嵌汇编可以参考:

1. GCC Inline Assembly HOWTO:
    http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html
2. Brennan's Guide to Inline Assembly:
    http://www.delorie.com/djgpp/doc/brennan/brennan_att_inline_djgpp.html