***************************************************************
开始啃用汇编写的字符串函数：
***************************************************************
---------------------------------------------------------------
_I386_STRING_H_宏
---------------------------------------------------------------
include/asm-i386/string.h
#ifndef _I386_STRING_H_
#define _I386_STRING_H_
当包括了该汇编写的字符串处理函数的头文件后，就定义这个宏予以说明。
---------------------------------------------------------------
__KERNEL__宏
---------------------------------------------------------------
include/asm-i386/string.h
#ifdef __KERNEL__
#include <linux/config.h>
注意：
只有定义的了__KERNEL__宏才会包含config.h头文件。
/*
* On a 486 or Pentium, we are better off not using the
* byte string operations. But on a 386 or a PPro the
* byte string ops are faster than doing it by hand
* (MUCH faster on a Pentium).
*/
下面这段注释很重要，建议看看：
/*
* This string-include defines all string functions as inline
* functions. Use gcc. It also assumes ds=es=data space, this *should be normal. Most of the string-functions are rather *heavily hand-optimized,
* see especially strsep,strstr,str[c]spn. They should work, but are not
* very easy to understand. Everything is done entirely within the register
* set, making the functions fast and clean. String instructions have been
* used through-out, making for "slightly" unclear code :-)
*
* NO Copyright (C) 1991, 1992 Linus Torvalds,
* consider these trivial functions to be PD.
*/
/* AK: in fact I bet it would be better to move this stuff all out of line. */
---------------------------------------------------------------
__HAVE_ARCH_STRCPY strcpy()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRCPY
static 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;
}
分析：
1.改写指令更清楚点：
1: ---> 1:
lodsb ---> mov al,ds:[si]
inc si
stosb ---> mov es:[di],al
inc di
testb al,al ---> test al,al
jne 1 ---> jne 1
明显该循环以0结束，当读到最后一个为0的字节后，该循环终止。
2.参数分析：
S: si/esi
&: 一般情况下，gcc会把输入操作数和输出操作数分配在同一个寄存器中，因为它假设在输出产生之前所有的输入都被消耗掉了。在输出操作数之前加上"&"，可以保证输出操作数不会覆盖掉输入，即gcc将为此输出操作数分配一个输入操作数还没使用的寄存器，除非特殊声明（如用数字0-9，见下面）
0-9: 指定一个操作数，它既作输入，又作输出，而且输入操作数和输出操作数占据同一个位置（寄存器）。数字标志只能出现在输入中，指出与第I个输出操作数占据同一个位置。
int d0, d1, d2;
"=&S" (d0), "=&D" (d1), "=&a" (d2)
"0" (src),"1" (dest)
代码分析：
该输入操作数src和dst是既用作为输入操作数，又用作输出操作数的。在最开始时，src，dest作为整个函数的入口参数。将src，dest这两个char*型指针送入si/esi，di/edi中。在"0"与"1"的作用下，src与d0占据同一个寄存器si/esi，dst与d1占据同一个寄存器di/edi，所以d0，d1将分别从si/esi，di/edi中取出src，dest存入其中的函数入口参数，从而实现了将参数转移到函数局部变量上来。在函数的执行中si/esi，di/edi寄存器发生了变化。最后函数执行完毕返回时。由于src，dest前面指定的"0"和"1"说明了src，dest是既用作为输入操作数，又用作输出操作数的。且又分别与第0，1个输出操作数d0，d1占据同一个寄存器si/esi，di/edi。且又在"&"的保护下，明确指明输出操作数不能覆盖输入操作数，所以src，dest分别存入si/esi，di/edi中作为输出。
D: di/edi
a: ax/eax
"memory": 这是register-modified部分。说明内存修改不可预测，禁止编译器将其值缓存于寄存器中。
3.指令分析：
lodsb: == mov al,[si]
inc si / dec si
stosb: == mov es:[di],al
inc di / dec di
testb: == test oprd1,oprd2
把oprd1 & oprd2指令执行后，设置标志ZF,PF,SF.
---------------------------------------------------------------
__HAVE_ARCH_STRNCPY strncpy()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRNCPY
static inline char * strncpy(char * dest,const char *src,size_t count)
{
int d0, d1, d2, d3;
__asm__ __volatile__(
"1:\tdecl %2\n\t"
"js 2f\n\t"
"lodsb\n\t"
"stosb\n\t"
"testb %%al,%%al\n\t"
"jne 1b\n\t"
"rep\n\t"
"stosb\n"
"2:"
: "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3)
:"0" (src),"1" (dest),"2" (count)
: "memory");
return dest;
}
指令重排：
1: decl ecx ===> 1: dec cx
js 2 ===> js 2
lodsb ===> mov al,ds:[si]
inc si / dec si
stosb ===> mov es:[di],al
inc di /dec si
testb al,al ===> test al,al
jne 1 ===> jne 1
rep ===> rep
stosb ===> mov es:[di],al
inc di /dec si
2: ===> 2:
分析：
对这段代码的分析分3种情况：
若内存中为: abcde\0，
1）要求复制3个字符：
（1）初始值CX == 3
然后每次减一，复制一个字符过去;然后再判断复制的该字符是否为0
3-->2: copy a
2-->1: copy b
1-->0: copy c
0-->-1 js 2
2）要求复制5个字符：
（1）初始值CX == 5
然后每次减一，复制一个字符过去;然后再判断复制的该字符是否为0
5-->4: copy a
4-->3: copy b
3-->2: copy c
2-->1: copy d
1-->0: copy e
0-->-1 js 2
（2）所以复制5个字符: 复制5个字符：5个字符.
3）要求复制6个字符：
（1）初始值CX == 6
然后每次减一，复制一个字符过去;然后再判断复制的该字符是否为0
6-->5: copy a
5-->4: copy b
4-->3: copy c
3-->2: copy d
2-->1: copy e
1-->0: copy \0
test al,al ===> al == \0 ZF == 1成立.
jne 1 ===> 不会跳转到1
继续往下执行：此时CX == 0，al == \0
rep: 判断CX是否为0，而cx == 0,就结束循环
（2）所以复制6个字符: 复制6个字符：5个字符+一个'\0'.
4）要求复制10个字符：
初始值CX == 10
然后每次减一，复制一个字符过去;然后再判断复制的该字符是否为0
10-->9: copy a
9-->8: copy b
8-->7: copy c
7-->6: copy d
6-->5: copy e
5-->4: copy \0
test al,al ===> al == \0 ZF == 1成立.
jne 1 ===> 不会跳转到1
继续往下执行：此时CX == 4，al == \0
rep : CX==4，CX!=0，(CX=CX-1)==3，继续往下执行
copy al == \0
重复循环：
rep : CX==3，CX!=0，(CX=CX-1)==2，继续往下执行
copy al == \0
重复循环：
rep : CX==2，CX!=0，(CX=CX-1)==1，继续往下执行
copy al == \0
重复循环：
rep : CX==1，CX!=0，(CX=CX-1)==0，继续往下执行
copy al == \0
重复循环：rep: cx==0，就结束循环
（2）所以复制10个字符，先复制6个字符：5个字符+一个'\0'，再填充4个'\0'
5）要求复制0个字符：
（1）初始值CX == 0
0-->-1 js 2
（2）所以复制了0个字符。
6）要求复制-1个字符：
（1）初始值CX == -1
-1-->-2 js 2
（2）所以复制了0个字符。
注意：
static inline char * strncpy(char * dest,const char *src,size_t count)，该函数中的count是送往cx/ecx中去了，而ecx最大为32位故对有符号数最多复制2G-1个字节，即字符串不能超过（2G-1）B。
当时产生疑问，当CX<=0时，都是不复制，为何不干脆用个无符号数，这样可以扩大到4G。请看下一个函数就解决了。因为当要把两个字符串串联起来时，也是用ECX作为计数器的，而ECX为32位，最大表示范围为4G-1，所以这两个字符串的长度就各分了一半为2G-1.
rep指令说明：
重复其后面的串操作指令动作，每一次重复都先判断CX是否为0，如为0就结束循环，否则CX的值减1。
类似于loop指令，但loop指令是先把CX的值减1，后再来判断是否为0。
注意在重复过程中的减一操作，不会影响各标志。
---------------------------------------------------------------
strcat()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRCAT
static inline char * strcat(char * dest,const char * src)
{
int d0, d1, d2, d3;
__asm__ __volatile__(
"repne\n\t"
"scasb\n\t"
"decl %1\n"
"1:\tlodsb\n\t"
"stosb\n\t"
"testb %%al,%%al\n\t"
"jne 1b"
: "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
: "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu)
:"memory");
return dest;
}
指令重排：
repne ===> while(ECX != 0 && ZF != 1)
scasb ===> {
if((al-es:[edi])==0)
ZF = 1;
edi++;
ECX--;
}
decl %1 ===> dec edi
1: ===> 1:
lodsb ===> mov al, ds:[esi]
inc esi
stosb ===> mov es:[edi], al
inc edi
testb %%al,%%al ===> test al, al
jne 1 ===> jne 1
参数初始值分析：
: "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
: "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu)
src ==> si/esi 此处为： esi
dest ==> di/edi 此处为： edi
0 ==> ax/eax 此处为： ax
0xffffffffu ===> ecx 此处为： ecx
所以，esi，edi指向两个字符串的起始位置；而ax==0；ecx==0xffffffffu
一般情况分析:
初始值：
esi--->'abc\0' (src)
edi--->'123\0' (dest)
al == 0
ecx == 0xffffffffu
while(ECX != 0 && ZF != 1)
{
if((al-es:[edi])==0)
ZF = 1;
edi++;
ECX--;
}
在edi所指向的字符串中一直找到以'\0'结束的地方。然后，edi指向'\0'字节的下一个字节，ECX--；再就循环结束。此时edi=edi+4；ECX=ECX-4。
说明：可见要么在es:[edi]所指向的字符串中找到为'\0'的字符，从而能结束循环。要么该字符串大于或等于0xffffffff(2G-1B)（不计结尾处的'\0'），使得ECX减为0，从而结束循环。
dec edi
edi = edi - 1;edi就指向es:[edi]所指向的字符串中的'\0'结束处字符。
此时寄存器的值为：
esi--->'abc\0' (src)
edi--->'123\0'中的为'\0'结尾处字符 (dest)
al == 0
ecx == 0xffffffffbu
1:
mov al, ds:[esi]
inc esi
mov es:[edi], al
inc edi
test al, al
jne 1
将ds:[esi]所指向的字符串复制到es:[edi]所指向的字符串的结尾处，从es:[edi]所指向字符串的'\0'处开始。该'\0'被覆盖。
esi--->'abc\0?'中的'?'处. (src)
edi--->'123abc\0?'中的最后为'?'结尾处字符 (dest)
al == 0 ，注意这个0是从esi所指向的字符串中取出的结尾字符，而非初始化的0
功能：strcat(char * dest,const char * src)，将src所指向的字符串复制到dest所指向的字符串的后面，将dest的'\0'覆盖，dest-src串成一个字符串后，再将src的'\0'复制过来使dest-src串结的字符串结束。
算法过程：
1.先扫描dest所指向的字符串，找到其的为'\0'处；
2.再从src所指向的字符串中一一将src所指向的字符串的各个字节复制到dest以'\0'为起始处。一直复制到src所指向的字符串的最后一个'\0'，将这个'\0'复制完后。就结束程序。
可见，该函数要求src，dest所向的字符串要以'\0'结束。
特殊情况1：
初始值：
esi--->'abc\0' (src)
edi--->'123456789... ...YX' 该字符串>=0xffffffff (dest)
设edi指向es这个段的开始处，为0基址。
即：edi[0]=='1'，edi[0xffffffff]=='X'，由于edi只有32位，表示范围为0X0--->0xffffffff，共4G个字符。所以就算该字符串有多于4G的字符，esi将无法引用，所以该edi所指向的字符串到edi[0xffffffff]=='X'止。字符再多，edi再++，edi又变为了0。
esi的分析也同此。
al == 0
ecx == 0xffffffffu
while(ECX != 0 && ZF != 1)
{
if((al-es:[edi])==0)
ZF = 1;
edi++;
ECX--;
}
循环体执行0xffffffff次
由于edi所指向的字符串>=0xffffffff，则在上面的寻找edi所指向的字符串的'\0'结束符时候，就会使ECX == 0，从而结束循环，此时edi指向(0xffffffff)处的字节。（不考虑段越界）
出循环时，ECX == 0，edi == 0xffffffff。
dec edi
edi = edi - 1;edi == 0xffffffff-1，即：edi[0xffffffff-1]=='Y'。
此时寄存器的值为：
esi--->'abc\0' (src)
edi--->'123456......YX'，edi==0xffffffff-1，edi就指向edi[0xffffffff-1]=='Y'（即：0xffffffff-1）处的字节 (dest)
al == 0
ecx == 0x00000000u
1:
mov al, ds:[esi]
inc esi
mov es:[edi], al
inc edi
test al, al
jne 1
将ds:[esi]所指向的字符串'abc\0'中的esi[0]=='a'复制到es:[edi]==es:edi[0xffffffff-1]=='Y'处。该es:[0xffffffff-1]=='Y'的字节'Y'被覆盖为'a'。即：esi[0]=='a'--->edi[0xffffffff-1]=='Y'
edi--->'123456......aX'。
这时，esi++,esi[1]=='b'；edi++,edi[0xffffffff]=='X'。
再从ds:[esi]中复制下一个esi[1]=='b'，到edi[0xffffffff]=='X'
edi--->'123.....ab'，edi++，edi==0x00000000，就指向edi[0]=='1'处的字节
esi++,esi[2]=='c'.esi--->'abc\0?'中的'c'处， (src)
再从esi[2]=='c'，复制到edi[0x00000000]=='1'处。
esi++,esi[3]=='\0'，esi--->'abc\0?'中的'\0'处. (src)
edi--->'c23.....ab'，edi++，edi==0x00000001，就指向edi[0x00000001]=='2'处的字节
再从esi[3]=='\0'，复制到edi[0x00000001]=='2'处。
esi++,esi[4]=='?'，esi--->'abc\0?'中的'?'处. (src)
edi--->'c\03.....ab'，edi++，edi==0x00000002，就指向edi[0x00000002]=='3'处的字节。
所以合并后的字符串为"c\0".
与此类似，当src中的字符等于4G时，情况同上；而当src,dest均等于4G时，情况也同上。
只要src，dest中的字符之和不大于4G-1，留一个给'\0'，就OK！
当src,dest中有一个或多个为空时，情况简单：
当dest为空，而src不为空：将src所指向的字符串连同'\0'复制到dest中去！
当src为空，而dest不为空：dest不动，只将src所指的'\0'，复制并覆盖dest中的最后一个'\0'！
当src为空，而dest为空：只将src所指的'\0'，复制并覆盖dest中那个'\0'！
参考资料：
S：si/esi
D：di/edi
a：ax/eax
c：cx/ecx
&: 一般情况下，gcc会把输入操作数和输出操作数分配在同一个寄存器中，因为它假设在输出产生之前所有的输入都被消耗掉了。在输出操作数之前加上"&"，可以保证输出操作数不会覆盖掉输入，即gcc将为此输出操作数分配一个输入操作数还没使用的寄存器，除非特殊声明（如用数字0-9，见下面）
0-9: 指定一个操作数，它既作输入，又作输出，而且输入操作数和输出操作数占据同一个位置（寄存器）。数字标志只能出现在输入中，指出与第I个输出操作数占据同一个位置。
---------------------------------------------------------------
strncat()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRNCAT
static inline char * strncat(char * dest,const char * src,size_t count)
{
int d0, d1, d2, d3;
__asm__ __volatile__(
"repne\n\t"
"scasb\n\t"
"decl %1\n\t"
"movl %8,%3\n"
"1:\tdecl %3\n\t"
"js 2f\n\t"
"lodsb\n\t"
"stosb\n\t"
"testb %%al,%%al\n\t"
"jne 1b\n"
"2:\txorl %2,%2\n\t"
"stosb"
: "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
: "0" (src),"1" (dest),"2" (0),"3" (0xffffffffu), "g" (count)
: "memory");
return dest;
}
指令重排：
repne ===> while(ecx != 0 && ZF != 1)
scasb ===> {
if((al-es:[edi])==0)
ZF = 1;
edi++;
ecx--;
}
decl %1 ===> decl edi
movl %8,%3 ===> movl count,ecx
1: ===> 1:
decl %3 ===> decl ecx
js 2 ===> js 2
lodsb ===> mov al,ds:[esi]
inc esi
stosb ===> mov es:[edi],al
inc edi
testb %%al,%%al ===> test al,al
jne 1 ===> jne 1
2: ===> 2:
xorl %2,%2 ===> xor eax,eax
stosb ===> mov es:[edi],al
inc edi
参数初始值分析：
: "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
: "0" (src),"1" (dest),"2" (0),"3" (0xffffffffu), "g" (count)
esi: esi = src
edi: edi = dest
eax: eax = 0
ecx: ecx = 0xffffffff
"g": 让编译器决定如何装入它。
代码分析：
while(ecx != 0 && ZF != 1)
{
if((al-es:[edi])==0)
ZF = 1;
edi++;
ecx--;
}
decl edi
在es:[edi]所指向的字符串中寻找'\0'处。然后回调edi指向该'\0'。
当该字符串在4G-1个字节中时，以'\0'正常结束。而当该字符串等于4G时，以ecx==0结束循环，edi回调后指向edi[0xffffffff-1]处。而字符串大于4G则不可能。
movl count,ecx
1:
decl ecx
js 2
mov al,ds:[esi]
inc esi
mov es:[edi],al
inc edi
test al,al
jne 1
2:
xor eax,eax
mov es:[edi],al
inc edi
1：表示开始复制esi所指向的字符串到edi中去。
2：表示复制结束后，在未尾再加个'\0'。
分情况讨论：
1）若count数大于ds:[esi]所指向的字符串中的字符个数。则esi所指向的字符串连同'\0'复制过了后，结束1：循环，在2：中再在'\0'的后面再复制一个'\0'，再edi++，结束程序。
2）若count数小于ds:[esi]所指向的字符串中的字符个数。则esi所指向的字符串中只复制count个后，ecx将减为-1后，由js 2跳出1：，在2：中接着再在后面复制一个'\0'，再edi++，结束程序。
3）若count等于ds:[esi]所指向的字符串中的字符个数。则esi所指向的字符串中复制count个后，ecx将减为0后，再在开始处ecx--，ecx == -1， 由js 2跳出1：，在2：中接着再在后面复制一个'\0'，再edi++，结束程序。
4）若count为负数，在开始处ecx--，ecx == 负数， 由js 2跳出1：，在2：中接着再在后面复制一个'\0'，即给edi所指向的字符串的那个'\0'再用'\0'重写一遍'\0'，再edi++，结束程序。
尽管可以复制4G个字节，由于count为有符号数，则最多复制2G-2（除掉'\0'）个字节。这显然是假设es:[edi]这个字符串最大为2G而来的，因为作者也不知道es:[edi]所指向的字符串有多长，虽然大部分不可能有2G，只有点点大，但作者却是作了最一般化的处理。
---------------------------------------------------------------
__HAVE_ARCH_STRCMP strcmp()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRCMP
static inline int strcmp(const char * cs,const char * ct)
{
int d0, d1;
register int __res;
__asm__ __volatile__(
"1:\tlodsb\n\t"
"scasb\n\t"
"jne 2f\n\t"
"testb %%al,%%al\n\t"
"jne 1b\n\t"
"xorl %%eax,%%eax\n\t"
"jmp 3f\n"
"2:\tsbbl %%eax,%%eax\n\t"
"orb $1,%%al\n"
"3:"
:"=a" (__res), "=&S" (d0), "=&D" (d1)
:"1" (cs),"2" (ct)
:"memory");
return __res;
}
初始值分析：
ax/eax：register int __res;
si/esi：const char* cs；
di/edi：const char* ct；
ZF == 0
指令重排：
1: lodsb ===> 1: mov al,ds:[esi]
inc esi
scasb ===> if((al-es:[edi])==0)
ZF = 1;
edi++;
jne 2 ===> jne 2;
testb %%al,%%al ===> testb al,al
jne 1 ===> jne 1
xorl %%eax,%%eax ===> xorl eax,eax
jmp 3 ===> jmp 3
2: sbbl %%eax,%%eax ===> 2: sbbl eax,eax
orb $1,%%al ===> orb al ，1
3: ===> 3:
1）代码剖析：
这是比较ds:[esi]和es:[edi]两个字符串是否相等。这两个字符串当以'\0'结束。函数返回值存放在eax中。将ds:[esi]中的每个字符送往al中，再与es:[edi]中的相应的各个字符进行比较，相同就置位ZF=1，然后测试al该字符是否为'\0'，如果不是则继续比较下一个字符；如果是'\0'，则就清eax为0，结束比较函数，该eax就为函数的返回值。
2）情况：
1.ds:[esi]和es:[edi]两个字符串是相等：同上，eax返回0
2.ds:[esi]和es:[edi]两个字符串不相等：
（1）ds:[esi]的字符串ASCII小于es:[edi]的ASCII
ds:[esi]=="abc\0"
es:[edi]=="xyz\0"
if((al-es:[edi])==0) ===>if( ('a'-'x')==0 )
ZF = 1; 条件不成立; CF == 1
edi++; edi++; edi指向'y'
jne 2 ; jne 2
2: sbbl eax,eax eax = eax-eax-CF=-1=0xffffffff
orb al ，1 al = 0xff
结论：
cs所指的字符串中第一个不同的字符的ASCII<ct所指的字符串第一个不同的字符的ASCII 返回值： eax==0xffffffff==-1
（2）ds:[esi]的字符串ASCII大于es:[edi]的ASCII
ds:[esi]=="xyz\0"
es:[edi]=="abc\0"
if((al-es:[edi])==0) ===>if( ('x'-'a')==0 )
ZF = 1; 条件不成立; CF == 0
edi++; edi++; edi指向'y'
jne 2 ; jne 2
2: sbbl eax,eax eax = eax-eax-CF=0
orb al ，1 al = 0|1=1=0x00000001
输出： eax==0x00000001
结论：
cs所指的字符串第一个不同的字符的ASCII>ct所指的字符串第一个不同的字符的ASCII 返回值： eax==0x00000001==1
（3）当其中一个字符串是另一个字符串的子字符串时:
ds:[esi]=="abc\0"
es:[edi]=="abc123\0"
当比较到'\0'-'1'时，结束循环，返回-1.
而是这种情况时候 ：
ds:[esi]=="abc123\0"
es:[edi]=="abc\0"
当比较到'1'-'\0'时，结束循环，返回1.
（4）若其中一个为无限长的字符串，另一个为有限长的字符串时：
则要么在其中的一个位置不同，跳出来同上面的分析；要么一个相当于为另一个的子字符串，分析同上。
可见，只要一个字符串符合以'\0'结束的规则，另一个字符串就算没有'\0'结束，也能正常终止函数。
（5）两个字符串均为无限长的字符串：
若两者在中间某处不等，就终止跳出，分析同上。
若两者完全相等且又无限长，则就地直比较下去。esi，edi将递增到0xffffffff，然后又回到0x00000000。若两字符串是从0x00000000开始的话，就又重复比较下去，一个死循环。若两字符串是从中间某处开始，这个内存中的0x00000000开始处或其后面有不同的字符，就会终止函数。
---------------------------------------------------------------
__HAVE_ARCH_STRNCMP strncmp()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRNCMP
static inline int strncmp(const char * cs,const char * ct,size_t count)
{
register int __res;
int d0, d1, d2;
__asm__ __volatile__(
"1:\tdecl %3\n\t"
"js 2f\n\t"
"lodsb\n\t"
"scasb\n\t"
"jne 3f\n\t"
"testb %%al,%%al\n\t"
"jne 1b\n"
"2:\txorl %%eax,%%eax\n\t"
"jmp 4f\n"
"3:\tsbbl %%eax,%%eax\n\t"
"orb $1,%%al\n"
"4:"
:"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
:"1" (cs),"2" (ct),"3" (count)
:"memory");
return __res;
}
初始值：
ax/eax：__res
si/esi：const char * cs
di/edi：const char * ct
cx/ecx：count
指令重排：
1: decl %3 ===> 1: decl ecx
js 2 ===> js 2
lodsb ===> mov al,ds:[esi]
inc esi
scasb ===> if((al-es:[edi])==0)
ZF = 1;
edi++;
jne 3 ===> jne 3
testb %%al,%%al ===> testb al,al
jne 1 ===> jne 1
2: xorl %%eax,%%eax ===> 2: xorl eax,eax
jmp 4 ===> jmp 4
3: sbbl %%eax,%%eax ===> 3: sbbl eax,eax
orb $1,%%al ===> orb 1,al
4: ===> 4:
此函数分析同上：
1）当指定的要比较的字符个数小于两个字符串长度时：
a：两字符串相同：ecx变为-1，由js 2出循环，再由xorl eax,eax将eax清0，作为函数的返回值返回。
b：两字符串不相同：由jne 3跳出来：
b-1：当cs所指的字符串第一个不同的字符的ASCII>ct所指的字符串第一个不同的字符的ASCII 返回值： eax==0x00000001==1；
b-2：当cs所指的字符串中第一个不同的字符的ASCII<ct所指的字符串第一个不同的字符的ASCII 返回值： eax==0xffffffff==-1
2）当指定的要比较的字符个数count等于两个字符串长度时：
a：两者相等时：
由testb al,al跳出循环，再由xorl eax,eax，将eax清0，返回这个0，结束函数。
b：两者不相等时：
同上分析。
3）当指定的要比较的字符个数count大于两个字符串时：
a：两者相等时：
比较到'\0'时，由testb al,al跳出循环，再由xorl eax,eax，将eax清0，返回这个0，结束函数。
b：两者不相等时：
同上分析。
4）当指定的要比较的字符个数count<=0时：
程序流程如下：
根本就不比较，直接返回0，结束函数。
1: decl %3 ===> 1: decl ecx
js 2 ===> js 2
... ...
2: xorl %%eax,%%eax ===> 2: xorl eax,eax
jmp 4 ===> jmp 4
... ...
4: ===> 4:
---------------------------------------------------------------
__HAVE_ARCH_STRCHR strchr()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRCHR
static inline char * strchr(const char * s, int c)
{
int d0;
register char * __res;
__asm__ __volatile__(
"movb %%al,%%ah\n"
"1:\tlodsb\n\t"
"cmpb %%ah,%%al\n\t"
"je 2f\n\t"
"testb %%al,%%al\n\t"
"jne 1b\n\t"
"movl $1,%1\n"
"2:\tmovl %1,%0\n\t"
"decl %0"
:"=a" (__res), "=&S" (d0)
:"1" (s),"0" (c)
:"memory");
return __res;
}
初始值：
ax/eax：int c
si/esi：const char *s
指令重排：
movb %%al,%%ah ===> movl al,ah
1: lodsb ===> 1: mov al,ds:[esi]
inc esi
cmpb %%ah,%%al ===> cmpb ah,al
je 2 ===> je 2
testb %%al,%%al ===> testb al,al
jne 1 ===> jne 1
movl $1,%1 ===> movl 1,esi
2: movl %1,%0 ===> 2: movl esi,eax
decl %0 ===> decl eax
功能：
ds:[esi]所指向的字符串以'\0'结束，在其中从前往后寻找c字符。如果找到，就返回该字符所在字符串中的位置。如果没找到，就返回0。
改写成C语言：
al == 要找寻的字符c;
esi == 该字符串的起始偏移地址;
int eax;
char ah;
ah = al;
1:
al = *(ds*16 + esi);
esi++;
if( al == ah )
goto 2;
if( al != 0 )
goto 1;
esi = 1;
2:
eax = esi;
eax--;
return eax;
极端情况：
如果ds:[esi]所指向的字符串不以'\0'结束的话，esi一个劲的++，直到变到0xffffffff，然后又变为0x00000000，又从头开始寻找，如果开头及到ds:[esi]处都找不到该字符c，或是也没有'\0'时，就陷入一个死循环。
---------------------------------------------------------------
__HAVE_ARCH_STRRCHR strrchr()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRRCHR
static inline char * strrchr(const char * s, int c)
{
int d0, d1;
register char * __res;
__asm__ __volatile__(
"movb %%al,%%ah\n"
"1:\tlodsb\n\t"
"cmpb %%ah,%%al\n\t"
"jne 2f\n\t"
"leal -1(%%esi),%0\n"
"2:\ttestb %%al,%%al\n\t"
"jne 1b"
:"=g" (__res), "=&S" (d0), "=&a" (d1)
:"0" (0),"1" (s),"2" (c)
:"memory");
return __res;
}
初始值分析：
__res ： 0
si/esi ： const char * s
ax/eax ： c
指令重排：
movb %%al,%%ah ===> movb al,ah
1: lodsb ===> 1: mov al,ds:[esi]
inc esi
cmpb %%ah,%%al ===> cmpb ah,al
jne 2 ===> jne 2
leal -1(%%esi),%0 ===> leal [esi-1],__res(g)
2: testb %%al,%%al ===> 2: testb al,al
jne 1 ===> jne 1
本函数分析类似上面的strchr()。只不过是找到在const char *s所指向的字符串c出现的最后的位置。找到了，返回其所在地址；没找到，返回0。分析类似上面的strchr()，不再重复。
strrchr - Find the last occurrence of a character in a string.
如果s为空指针，则后果无法预料。
---------------------------------------------------------------
__HAVE_ARCH_STRLEN strlen()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRLEN
static inline size_t strlen(const char * s)
{
int d0;
register int __res;
__asm__ __volatile__(
"repne\n\t"
"scasb\n\t"
"notl %0\n\t"
"decl %0"
:"=c" (__res), "=&D" (d0)
:"1" (s),"a" (0), "0" (0xffffffffu)
:"memory");
return __res;
}
参数初始值分析：
di/edi：const char * s
ax/eax：0
cx/ecx：0xffffffff
size_t ecx = 0xffffffff;
ZF = 0;
char * edi = s;
指令重排： eax = 0;
repne ===> while(ecx != 0 && ZF == 0)
scasb ===> {
if((al-es:[edi])==0)
ZF = 1;
edi++;
ecx--;
}
notl %0 ===> ecx = !ecx;
decl %0 ===> ecx--;
此处函数主要是ecx = !ecx，由于ecx是从0xffffffff递减下来的。记住：递减计数和递增计数是一样的计数，只要在最后，取个反，就让两者相互转化了。在递减计数或递增计数过程中多计数了的值，在最后取反后，要（转化后的数--）。
至于各种情况分析，很简单，同前，无须多说。
而对于极端情况分析，edi++,ecx--到0xfffffffff--->0x00000000，情况同前。
参考：
typedef unsigned int __kernel_size_t;
typedef __kernel_size_t size_t;
---------------------------------------------------------------
__memcpy()
---------------------------------------------------------------
include/asm-i386/string.h
static inline void * __memcpy(void * to, const void * from, size_t n)
{
int d0, d1, d2;
__asm__ __volatile__(
"rep ; movsl\n\t"
"movl %4,%%ecx\n\t"
"andl $3,%%ecx\n\t"
#if 1 /* want to pay 2 byte penalty for a chance to skip microcoded rep? */
"jz 1f\n\t"
#endif
"rep ; movsb\n\t"
"1:"
: "=&c" (d0), "=&D" (d1), "=&S" (d2)
: "0" (n/4), "g" (n), "1" ((long) to), "2" ((long) from)
: "memory");
return (to);
}
参数初始值：
cx/ecx：n/4
di/edi：to
si/esi：from
指令重排： ecx = n/4;
rep ===> while( ecx-- != 0 )
movsl ===> (long)ds:[esi] = (long)es:[edi];
movl %4,%%ecx ===> ecx = n;
andl $3,%%ecx ===> ZF = ecx & 0x00000003
#if 1
jz 1 ===> if(ZF==0) goto 1;
#endif
rep ===> while( ecx-- != 0 )
movsb ===> (char)ds:[esi] = (char)es:[edi];
1: ===> 1:
分析：
1.先进行4B为单位的复制：
ecx = n/4;然后就开始复制。
2.求出ecx = ecx % 4；对不足4B的字节进行复制。
ZF = ecx & 0x00000003;
以上为一般情况分析。
3.如果 0< n <4:
则ecx = n/4 == 0;
if( ecx-- !=0 )条件不成立，不进行4B单位的复制。直接进行以字节为单位的复制。
4.如果n = 0:
两个if条件均不满足，根本就不复制。
5.如果n < 0:
函数依然工作，只是牵涉到补码了，后果未知。
如果0<n<4
参考：
typedef unsigned int __kernel_size_t;
typedef __kernel_size_t size_t;
---------------------------------------------------------------
__constant_memcpy()
---------------------------------------------------------------
include/asm-i386/string.h
/*
* This looks ugly, but the compiler can optimize it totally,
* as the count is constant.
*/
static inline void * __constant_memcpy(void * to, const void * from, size_t n)
{
long esi, edi;
if (!n) return to;
#if 1 /* want to do small copies with non-string ops? */
switch (n)
{
case 1: *(char*)to = *(char*)from; return to;
case 2: *(short*)to = *(short*)from; return to;
case 4: *(int*)to = *(int*)from; return to;
#if 1 /* including those doable with two moves? */
case 3: *(short*)to = *(short*)from;
*((char*)to+2) = *((char*)from+2); return to;
case 5: *(int*)to = *(int*)from;
*((char*)to+4) = *((char*)from+4); return to;
case 6: *(int*)to = *(int*)from;
*((short*)to+2) = *((short*)from+2); return to;
case 8: *(int*)to = *(int*)from;
*((int*)to+1) = *((int*)from+1); return to;
#endif/* 1 */
}/* switch */
#endif/* 1 */
esi = (long) from;
edi = (long) to;
if (n >= 5*4)
{
/* large block: use rep prefix */
int ecx;
__asm__ __volatile__(
"rep ; movsl"
: "=&c" (ecx), "=&D" (edi), "=&S" (esi)
: "0" (n/4), "1" (edi),"2" (esi)
: "memory"
);
}/* if */
else
{
/* small block: don't clobber ecx + smaller code */
if (n >= 4*4) __asm__ __volatile__(
"movsl"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
if (n >= 3*4) __asm__ __volatile__(
"movsl"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
if (n >= 2*4) __asm__ __volatile__(
"movsl"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
if (n >= 1*4) __asm__ __volatile__(
"movsl"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
}/* else */
switch (n % 4)
{
/* tail */
case 0: return to;
case 1: __asm__ __volatile__(
"movsb"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
return to;
case 2: __asm__ __volatile__(
"movsw"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
return to;
default: __asm__ __volatile__(
"movsw\n\tmovsb"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
return to;
}/* switch */
}
代码分析：
1.对1-8，（一包括7）个字节的复制，采用不同类型的变量进行复制：
#if 1 /* want to do small copies with non-string ops? */
switch (n)
{
case 1: *(char*)to = *(char*)from; return to;
case 2: *(short*)to = *(short*)from; return to;
case 4: *(int*)to = *(int*)from; return to;
#if 1 /* including those doable with two moves? */
case 3: *(short*)to = *(short*)from;
*((char*)to+2) = *((char*)from+2); return to;
case 5: *(int*)to = *(int*)from;
*((char*)to+4) = *((char*)from+4); return to;
case 6: *(int*)to = *(int*)from;
*((short*)to+2) = *((short*)from+2); return to;
case 8: *(int*)to = *(int*)from;
*((int*)to+1) = *((int*)from+1); return to;
#endif/* 1 */
}/* switch */
#endif/* 1 */
当要复制的字节数为：1-8个之间时。执行以上这段程序。当字节数为：
1个：用char *
2个：用short *
4个：用int*
2.复制的字节数在[20,>20]，[16，19]，[12，15]，[8，11]，[4，7]：
if (n >= 5*4) //当要复制的字节数在[20,>20]时：
{
/* large block: use rep prefix */
int ecx;
__asm__ __volatile__(
"rep ; movsl"
: "=&c" (ecx), "=&D" (edi), "=&S" (esi)
: "0" (n/4), "1" (edi),"2" (esi)
: "memory"
);
}/* if */
分析： esi = (long) from;
edi = (long) to;
ecx = n/4;
rep ===> if( ecx-- != 0 )
movsl ===> {
(unsigned long)es:[edi] = ds:[esi];
}
然后就转入下一个switch{}结构体中执行：
switch (n % 4)
{
/* tail */
case 0: return to;
case 1: __asm__ __volatile__(
"movsb"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
return to;
case 2: __asm__ __volatile__(
"movsw"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
return to;
default: __asm__ __volatile__(
"movsw\n\tmovsb"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
return to;
}/* switch */
代码简单，不再啰嗦。就是再将剩下的不足4B的字节复制过去。
default是表示，n%4 == 3，先复制一个字，再复制一个字节，共3B。
--------------------------------------------------------------
else //当要复制的字节数在 4<= n <=19时：
{
/* small block: don't clobber ecx + smaller code */
//当要复制的字节数在[16,19]时：
if (n >= 4*4) __asm__ __volatile__(
"movsl"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
//当要复制的字节数在[12,15]时：
if (n >= 3*4) __asm__ __volatile__(
"movsl"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
//当要复制的字节数在[8,11]时：
if (n >= 2*4) __asm__ __volatile__(
"movsl"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
//当要复制的字节数在[4,7]时：
if (n >= 1*4) __asm__ __volatile__(
"movsl"
:"=&D"(edi),"=&S"(esi)
:"0"(edi),"1"(esi)
:"memory");
}/* else */
分析：
???: ecx初始值没指定？？？ecx = n/4这才对啊！
其实这些代码合并成一个：
if( n >- 1*4 )//7,[9,19]
__asm__ __volatile__(
"rep; movsl\t\n"
:"=&D"(edi),"=&S"(esi),"=C"
:"0"(edi),"1"(esi),"2"(n/4)
:"memory");
注意：
__constant_memcpy()与__memcpy()很相同，参数个数和类型一样，同时功能作用也一样。
---------------------------------------------------------------
__constant_memcpy3d()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_MEMCPY
#ifdef CONFIG_X86_USE_3DNOW/* 对下面的__constant_memcpy3d()
__memcpy3d()，memcpy()*/
#include <asm/mmx.h>
/*
* This CPU favours 3DNow strongly (eg AMD Athlon)
*/
static inline void * __constant_memcpy3d(void * to, const void * from, size_t len)
{
if (len < 512)
return __constant_memcpy(to, from, len);
return _mmx_memcpy(to, from, len);
}
？？？？_mmx_memcpy()函数找不到，只好罢手！！！
---------------------------------------------------------------
__memcpy3d()
---------------------------------------------------------------
include/asm-i386/string.h
static __inline__ void *__memcpy3d(void *to, const void *from, size_t len)
{
if (len < 512)
return __memcpy(to, from, len);
return _mmx_memcpy(to, from, len);
}
？？？？_mmx_memcpy()函数找不到，只好罢手！！！
---------------------------------------------------------------
memcpy()
---------------------------------------------------------------
include/asm-i386/string.h
#define memcpy(t, f, n) \
(__builtin_constant_p(n) ? \
__constant_memcpy3d((t),(f),(n)) : \
__memcpy3d((t),(f),(n)))
#else/* CONFIG_X86_USE_3DNOW */
/*
* No 3D Now!
*/
#define memcpy(t, f, n) \
(__builtin_constant_p(n) ? \
__constant_memcpy((t),(f),(n)) : \
__memcpy((t),(f),(n)))
#endif/* CONFIG_X86_USE_3DNOW */
int __builtin_constant_p(exp)学习:
You can use the built-in function __builtin_constant_p to determine if a value is known to be constant at compile-time and hence that GCC can perform constantfolding on expressions involving that value. The argument of the function is the value to test. The function returns the integer 1 if the argument is known to be a compiletime constant and 0 if it is not known to be a compile-time constant. A return of 0 does not indicate that the value is not a constant, but merely that GCC cannot prove it is a constant with the specified value of the ‘-O’ option.
You would typically use this function in an embedded application where memory was a critical resource. If you have some complex calculation, you may want it to be folded if it involves constants, but need to call a function if it does not. For example:
#define Scale_Value(X) \
(__builtin_constant_p (X) \
? ((X) * SCALE + OFFSET) : Scale (X))
You may use this built-in function in either a macro or an inline function. However, if you use it in an inlined function and pass an argument of the function as the argument to the built-in, GCC will never return 1 when you call the inline function with a string constant or compound literal and will not return 1 when you pass a constant numeric value to the inline function unless you specify the ‘-O’ option.
使用__builtin_constant_p()要和gcc中的-O选项配合使用。
You may also use __builtin_constant_p in initializers for static data. For instance,you can write
static const int table[] = {
__builtin_constant_p (EXPRESSION) ? (EXPRESSION) : -1,
/* . . . */
};
This is an acceptable initializer even if EXPRESSION is not a constant expression.
GCC must be more conservative about evaluating the built-in in this case, because it has no opportunity to perform optimization.Previous versions of GCC did not accept this built-in in data initializers. The earliest version where it is completely safe is 3.0.1.
---------------------------------------------------------------
__HAVE_ARCH_MEMMOVE
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_MEMMOVE
void *memmove(void * dest,const void * src, size_t n);
memmove()延用string.c中的函数。
#define memcmp __builtin_memcmp
---------------------------------------------------------------
__HAVE_ARCH_MEMCHR memchr()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_MEMCHR
static inline void * memchr(const void * cs,int c,size_t count)
{
int d0;
register void * __res;
if (!count) return NULL;
__asm__ __volatile__(
"repne\n\t"
"scasb\n\t"
"je 1f\n\t"
"movl $1,%0\n"
"1:\tdecl %0"
:"=D" (__res), "=&c" (d0)
:"a" (c),"0" (cs),"1" (count)
:"memory");
return __res;
}
功能：cs指定内存的起始位置，count指定查找的个数，c指定要查找的内容。在以cs指定的内存为查找的起始位置，以cs+count为终止位置来查找内容c。找到就返回所找到的位置；没找到就返回0。
参数初始值：
ax/eax: c
di/edi: const void * cs
cx/ecx: count
ZF = 0;
ax = c;
edi = cs;
ecx = count;
指令重排：
repne ===> while( ecx-- != 0 && ZF == 0)
{
scasb ===> if((al-es:[edi++])==0)
ZF = 1;
}
je 1 ===> if(ZF == 1) goto 1;
movl $1,%0 ===> edi = 1;
1: ===> 1:
decl %0 ===> edi--;
return edi;
返回值：如果找到了c，就返回c所在的位置，如果没找到，就返回0。
一般情况代码简单，就此住手。
特殊情况：
1.若ecx==0：则两个if条件均不满足，直接返回0，结束程序。
2.若ecx为0xffffffff巨大的数：要么在其中能找到能与c相匹配的数，返回其位置；要么找不到，当ecx--变为0时，（当ecx==0时，跳出循环时，ecx还要再--又变为0xffffffff），并返回0。
3.此处无负数，故ecx<0一情况无须多虑。由于是内存操作函数，连'\0'也可以进入比较范围。
---------------------------------------------------------------
__memset_generic()
---------------------------------------------------------------
include/asm-i386/string.h
static inline void * __memset_generic(void * s, char c,size_t count)
{
int d0, d1;
__asm__ __volatile__(
"rep\n\t"
"stosb"
: "=&c" (d0), "=&D" (d1)
:"a" (c),"1" (s),"0" (count)
:"memory");
return s;
}
ax = c;
edi = s;
ecx = count;
rep ====> while( ecx !=0 )
{
stosb ====> es:[edi] = al;
}
return s;
---------------------------------------------------------------
__constant_count_memset()
---------------------------------------------------------------
include/asm-i386/string.h
/* we might want to write optimized versions of these later */
#define __constant_count_memset(s,c,count) __memset_generic((s),(c),(count))
---------------------------------------------------------------
__constant_c_memset()
---------------------------------------------------------------
include/asm-i386/string.h
/*
* memset(x,0,y) is a reasonably common thing to do, so we want to fill
* things 32 bits at a time even when we don't know the size of the
* area at compile-time..
*/
static inline void * __constant_c_memset(void * s, unsigned long c, size_t count)
{
int d0, d1;
__asm__ __volatile__(
"rep ; stosl\n\t"
"testb $2,%b3\n\t"
"je 1f\n\t"
"stosw\n"
"1:\ttestb $1,%b3\n\t"
"je 2f\n\t"
"stosb\n"
"2:"
:"=&c" (d0), "=&D" (d1)
:"a" (c), "q" (count), "0" (count/4), "1" ((long) s)
:"memory");
return (s);
}
参数初始值分析：
ax/eax: c
cx/ecx: count/4
di/edi: void *s
指令重排：
rep ====> while( ecx-- != 0 )
{
stosl ====> (long)es:[edi] = eax;
edi += 4;
}
testb $2,%b3 ====> if( (0x02 & (char)count) == 0 )
je 1 ====> goto 1;
stosw ====> (short)es:[edi] = ax;
edi += 2;
1: testb $1,%b3 ====> 1: if( (0x01 & (char)count) == 0)
je 2 ====> goto 2;
stosb ====> (char)es:[edi] = al;
2: ====> 2:
分析：
先以4B为单位进行复制字节。完成后，再分别测试倒数第2位，最后一位是否为1，从而判断是否还剩3,2,1,0个字节。若还剩3B，则复制一个字后，还剩1B；若还剩2B，则复制一个字后，还剩0B.与后面还剩2,0B的情况一样。
特殊情况：
若count==0，则while，if条件均不满足，跳出循环。
---------------------------------------------------------------
__HAVE_ARCH_STRNLEN strnlen()
---------------------------------------------------------------
include/asm-i386/string.h
/* Added by Gertjan van Wingerde to make minix and sysv module work */
#define __HAVE_ARCH_STRNLEN
static inline size_t strnlen(const char * s, size_t count)
{
int d0;
register int __res;
__asm__ __volatile__(
"movl %2,%0\n\t"
"jmp 2f\n"
"1:\tcmpb $0,(%0)\n\t"
"je 3f\n\t"
"incl %0\n"
"2:\tdecl %1\n\t"
"cmpl $-1,%1\n\t"
"jne 1b\n"
"3:\tsubl %2,%0"
:"=a" (__res), "=&d" (d0)
:"c" (s),"1" (count)
:"memory");
return __res;
}
/* end of additional stuff */
参数初始值分析：
cx/ecx: const char * s
dx/edx: count
ax/eax: __res
指令重排：
size_t edx;
edx = count;
char * eax,ecx;
ecx = s;
movl %2,%0 ====> eax = s; //ecx = eax = s;
jmp 2 ====> goto 2;
1: cmpb $0,(%0) ====> 1: if( ((char)(ds:[eax]))==0 )
je 3 ====> goto 3;
incl %0 ====> eax++;
2: decl %1 ====> 2: edx--;
cmpl $-1,%1 ====> if( (0xffffffff & edx) != 0)
jne 1 ====> goto 1;
3: subl %2,%0 ====> 3: eax -= ecx;
return eax;
各种情况分析：
1.字符串的长度（不含'\0'） < count：
s==>"abcd\0?"
count == 5: eax已经指向'\0'，但还尚未比较之。edx==1，经过edx--后变为edx==0，从而结束函数。再经过eax-=ecx;后，eax==4，为字符串的长度（不含'\0'）作为函数返回值。
count == 6: edx==1，尚未变为0，但eax=='\0'，且经过if条件的比较后，跳出循环，eax==4，为字符串的长度（不含'\0'）作为函数返回值。
2.字符串的长度（不含'\0'） == count：
s==>"abcd\0?"
count == 4: count总共比较3次，eax最后指向'd'（但尚未比较），eax-=ecx后，eax==3，为count-1的值，也即循环的次数。
3.字符串的长度（不含'\0'） > count：
s==>"abcd\0?"
count == 3: 共循环2次后，count变为0，从而结束循环。此时比较了两个字符'a'和'b'，eax指向'c'，但尚未比较。eax-=ecx后，eax=2，为count-1，也就是所循环的次数。
4.字符串的长度（不含'\0'）== 0：
s==>"\0?"
count == 4: 返回eax==0。
5.count == 1
s==>"abcd\0?"
count == 1: 返回eax==0。
6.count == 0
s==>"abcd\0?" : edx--后，edx变为0xffffffff，要么当edx又减为0时，终止循环，eax当为0，共加了0xffffffff次，又回到原来的值；要么找到为'\0'处，此时返回字符串的长度（不含'\0'）。
功能分析：
s指定一个字符串的首地址，count指定一个长度。对该字符串进行扫描，若字符串的总长度（不含'\0'）小于count，就返回该字符串的总长度（不含'\0'）；若字符串的总长度（不含'\0'）>= count，就返回count-1；若字符串的总长度（不含'\0'）== 0或count==1就返回0。若count==0则情况未知。
---------------------------------------------------------------
__HAVE_ARCH_STRSTR strstr()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_STRSTR
extern char *strstr(const char *cs, const char *ct);
此处当是引用string.c中的strstr()函数。
---------------------------------------------------------------
__constant_c_and_count_memset()
---------------------------------------------------------------
include/asm-i386/string.h
/*
* This looks horribly ugly, but the compiler can optimize it totally,
* as we by now know that both pattern and count is constant..
*/
static inline void * __constant_c_and_count_memset(void * s, unsigned long pattern, size_t count)
{
switch (count)
{
case 0:
return s;
case 1:
*(unsigned char *)s = pattern;
return s;
case 2:
*(unsigned short *)s = pattern;
return s;
case 3:
*(unsigned short *)s = pattern;
*(2+(unsigned char *)s) = pattern;
return s;
case 4:
*(unsigned long *)s = pattern;
return s;
}
#define COMMON(x) \
__asm__ __volatile__( \
"rep ; stosl" \
x \
: "=&c" (d0), "=&D" (d1) \
: "a" (pattern),"0" (count/4),"1" ((long) s) \
: "memory")
{
int d0, d1;
switch (count % 4)
{
case 0: COMMON(""); return s;
case 1: COMMON("\n\tstosb"); return s;
case 2: COMMON("\n\tstosw"); return s;
default: COMMON("\n\tstosw\n\tstosb"); return s;
}
}
#undef COMMON
}
分析：
1.count == [0,4] :
switch (count)
{
case 0:
return s;
case 1:
*(unsigned char *)s = pattern;
return s;
case 2:
*(unsigned short *)s = pattern;
return s;
case 3:
*(unsigned short *)s = pattern;
*(2+(unsigned char *)s) = pattern;
return s;
case 4:
*(unsigned long *)s = pattern;
return s;
}
2.count > 4 :
#define COMMON(x) \
__asm__ __volatile__( \
"rep ; stosl" \
x \
: "=&c" (d0), "=&D" (d1) \
: "a" (pattern),"0" (count/4),"1" ((long) s) \
: "memory")
{
int d0, d1;
switch (count % 4)
{
case 0: COMMON(""); return s;
case 1: COMMON("\n\tstosb"); return s;
case 2: COMMON("\n\tstosw"); return s;
default: COMMON("\n\tstosw\n\tstosb"); return s;
}
}
#undef COMMON
a):注意这种在函数内部使用宏的方法：
1）先用#define定义宏；
2）再用一对{}括住函数体；
3）再在后面用#undef取消所定义的的宏；
b):#define COMMON(x) \
__asm__ __volatile__( \
"rep ; stosl" \
x \
: "=&c" (d0), "=&D" (d1) \
: "a" (pattern),"0" (count/4),"1" ((long) s) \
: "memory")
参数初始值：
ax/eax: pattern
cx/ecx: count/4
di/edi: s
指令重排：
COMMON("")展开为：
eax = pattern;
edi = s;
ecx = count/4;
rep ===> while( ecx-- != 0 )
{
stosl ===> es:[edi] = eax;
edi += 4;
}
return s;
COMMON("\n\tstosb")展开为：
eax = pattern;
edi = s;
ecx = count/4;
rep ===> while( ecx-- != 0 )
{
stosl ===> es:[edi] = eax;
edi += 4;
}
x ===> stosb ===> es:[edi] = al;
edi += 1;
return s;
COMMON("\n\tstosw")展开为：
eax = pattern;
edi = s;
ecx = count/4;
rep ===> while( ecx-- != 0 )
{
stosl ===> es:[edi] = eax;
edi += 4;
}
x ===> stosw ===> es:[edi] = ax;
edi += 2;
return s;
COMMON("\n\tstosw\n\tstosb")展开为：
eax = pattern;
edi = s;
ecx = count/4;
rep ===> while( ecx-- != 0 )
{
stosl ===> es:[edi] = eax;
edi += 4;
}
x => stosw;stosb=> es:[edi] = ax;
edi += 2;
es:[edi] = al;
edi += 1;
return s;
c): 进一步分析：
{
int d0, d1;
switch (count % 4)
{
case 0: COMMON(""); return s;
case 1: COMMON("\n\tstosb"); return s;
case 2: COMMON("\n\tstosw"); return s;
default: COMMON("\n\tstosw\n\tstosb"); return s;
}
}
对剩下的字节数进行移动！！！
---------------------------------------------------------------
__constant_c_x_memset()
---------------------------------------------------------------
include/asm-i386/string.h
#define __constant_c_x_memset(s, c, count) \
(__builtin_constant_p(count) ? \
__constant_c_and_count_memset((s),(c),(count)) : \
__constant_c_memset((s),(c),(count)))
功能：对s所指定的的字符串用c填充指定的个数count个字节。
参考资料：
1.__constant_c_and_count_memset():
static inline void * __constant_c_and_count_memset(void * s, unsigned long pattern, size_t count)
{
switch (count)
{
case 0:
return s;
case 1:
*(unsigned char *)s = pattern;
return s;
case 2:
*(unsigned short *)s = pattern;
return s;
case 3:
*(unsigned short *)s = pattern;
*(2+(unsigned char *)s) = pattern;
return s;
case 4:
*(unsigned long *)s = pattern;
return s;
}
#define COMMON(x) \
__asm__ __volatile__( \
"rep ; stosl" \
x \
: "=&c" (d0), "=&D" (d1) \
: "a" (pattern),"0" (count/4),"1" ((long) s) \
: "memory")
{
int d0, d1;
switch (count % 4)
{
case 0: COMMON(""); return s;
case 1: COMMON("\n\tstosb"); return s;
case 2: COMMON("\n\tstosw"); return s;
default: COMMON("\n\tstosw\n\tstosb"); return s;
}
}
#undef COMMON
}
2.__constant_c_memset():
static inline void * __constant_c_memset(void * s, unsigned long c, size_t count)
{
int d0, d1;
__asm__ __volatile__(
"rep ; stosl\n\t"
"testb $2,%b3\n\t"
"je 1f\n\t"
"stosw\n"
"1:\ttestb $1,%b3\n\t"
"je 2f\n\t"
"stosb\n"
"2:"
:"=&c" (d0), "=&D" (d1)
:"a" (c), "q" (count), "0" (count/4), "1" ((long) s)
:"memory");
return (s);
}
---------------------------------------------------------------
__memset()
---------------------------------------------------------------
include/asm-i386/string.h
#define __memset(s, c, count) \
(__builtin_constant_p(count) ? \
__constant_count_memset((s),(c),(count)) : \
__memset_generic((s),(c),(count)))
功能：将s所指定的内存区域用c字符填充count次数。
参考资料：
1.__constant_count_memset():
#define __constant_count_memset(s,c,count) __memset_generic((s),(c),(count))
2.__memset_generic():
static inline void * __memset_generic(void * s, char c,size_t count)
{
int d0, d1;
__asm__ __volatile__(
"rep\n\t"
"stosb"
: "=&c" (d0), "=&D" (d1)
:"a" (c),"1" (s),"0" (count)
:"memory");
return s;
}
---------------------------------------------------------------
__HAVE_ARCH_MEMSET memset()
---------------------------------------------------------------
include/asm-i386/string.h
#define __HAVE_ARCH_MEMSET
#define memset(s, c, count) \
(__builtin_constant_p(c) ? \
__constant_c_x_memset((s),(0x01010101UL*(unsigned char)(c)),(count)) : \
__memset((s),(c),(count)))
功能同上：
参考资料：
1.__constant_c_x_memset():
#define __constant_c_x_memset(s, c, count) \
(__builtin_constant_p(count) ? \
__constant_c_and_count_memset((s),(c),(count)) : \
__constant_c_memset((s),(c),(count)))
2.__memset()同上。
?????(0x01010101UL*(unsigned char)(c))是什么意思？？？
---------------------------------------------------------------
__HAVE_ARCH_MEMSCAN memscan()
---------------------------------------------------------------
include/asm-i386/string.h
/*
* find the first occurrence of byte 'c', or 1 past the area if none
*/
#define __HAVE_ARCH_MEMSCAN
static inline void * memscan(void * addr, int c, size_t size)
{
if (!size) return addr;
__asm__("repnz; scasb\n\t"
"jnz 1f\n\t"
"dec %%edi\n"
"1:"
: "=D" (addr), "=c" (size)
: "0" (addr), "1" (size), "a" (c)
: "memory");
return addr;
}
重排指令：
edi = addr;
ecx = size;
eax = c;
ZF = 0;
repnz ====> while( ecx-- != 0 && ZF == 0 )
{
scasb ====> if( (al - es:[edi++]) == 0 )
ZF = 1;
}
jnz 1 ====> if( ZF != 0 ) goto 1;
dec %%edi ====> edi--;
1: ====> 1:
此函数的汇编非常简单，就不再啰嗦了。
线性扫描内存，找到了第一个'c'，就返回找到的地址；没找到就返回所比较的最后一个位置。
#endif /* __KERNEL__ */
#endif /* !_I386_STRING_H_ */
***************************************************************
汇编写的字符串函数终于啃完了！！！