제 목:[강좌] 인라인 어셈블리를 분석하자. (5) 관련자료:없음 [573] 보낸이:한동훈 (ddoch ) 1997-02-20 19:24 조회:588 2.15 memcpy 이제 부터는 작은 것 몇 개만 보면 끝날 것이다. 푸근히 마음을 가 지고 여유있게 살펴보도록 하자. 길어봐야 10줄짜리 들이다. --------------------------------------------------------------------- extern inline void * __memcpy(void * to, const void * from, size_t n) { __asm__ __volatile__( "cld\n\t" "rep ; movsl\n\t" "testb $2,%b1\n\t" "je 1f\n\t" "movsw\n" "1:\ttestb $1,%b1\n\t" "je 2f\n\t" "movsb\n" "2:" : /* no output */ :"c" (n/4), "q" (n),"D" ((long) to),"S" ((long) from) : "cx","di","si","memory"); return (to); } ---------------------------------------------------------------------- memcpy 는 잘 아시다시피 from에서 to로 n바이트를 메모리 복사한다. * output memory 복사 이므로 반환값은 없다. * input "q"는 ax, bx, cx, dx 중 하나의 레지스터에 'n'의 값을 할당하겠 다고 컴파일러에게 일러주는 것이다. ecx에 n/4를, "q"에 n을, edi에 (long)to를, esi에 (long)from을 각기 값을 전달한다. (long)과 같이 특정하게 형을 변환함으로써 그 크기에 따른 레지스터(여기에서는 edi등..)을 사용할 수 있다. to는 복사될 곳이므로 dest index에 넣어두고, from은 복사할 곳 이므로 source index에 값을 저장하여 이후에 문자열 관련 명령 을 사용하여 원하는 작업을 할 수 있다. * commands rep; movsl과 같이 명령들을 ';'로 분리하여 한줄에 적을 수도 있다. 이 명령에 의해 esi(from)에서 edi(to)로 n/4만큼 복사된다. 한번 복사될 때는 4바이트(movsl-long)씩 되므로 만일 n을 15로 줄 경우는 4의 배수인 12만큼 복사되고 3바이트가 남게 된다. 이렇게 4바이트 단위로 복사하는 것이 4바이트가 기본 데이타 형인 32비트 운영체제 에서 더 효율성이 좋은 모양이다. 나머지 3바이트는 뒤에서 복사를 한다. 중간에 %b1(%bl-%BL과 혼동하지 말라)이 있는 데 이것은 아마도 %1+ byte 의 의미같다. 즉, %1은 n의 값이므로 testb $2, %b1은 n의 하위 1바이트와 상수 2를 & 연산을 한다는 이야기로 해석하면 정확할 것같 다. 15바이트 일 경우를 예로 들면, 15 : 1111 2 : 0010 & ----------- 0010 즉, 이 연산은 n의 2번째 비트가 1인지를 검사한다. 0이라면 1첫번째 비트를 검사하는 1f로 가고, 1이라면 2비트를 복사를 하고 1번째 비트 를 testb $1, %b1과 같이 검사하여 1이면 1바이트를 더 복사하고, 0이 면 종료한다. 아주 쉽게 이해가 될 것이다. 이번에는 아주 재미있는 루틴이다. 인라인 어셈블리를 어떻게 C 에서 define 해서 사용할 수 있는 지의 하나의 예로서 흥미롭게 살펴보자. ----------------------------------------------------------------------- /* * This looks horribly ugly, but the compiler can optimize it totally, * as the count is constant. */ extern inline void * __constant_memcpy(void * to, const void * from, \ size_t n) { switch (n) { case 0: return to; case 1: *(unsigned char *)to = *(const unsigned char *)from; return to; case 2: *(unsigned short *)to = *(const unsigned short *)from; return to; case 3: *(unsigned short *)to = *(const unsigned short *)from; *(2+(unsigned char *)to) = *(2+(const unsigned char *)from); return to; case 4: *(unsigned long *)to = *(const unsigned long *)from; return to; } #define COMMON(x) \ __asm__("cld\n\t" \ "rep ; movsl" \ x \ : /* no outputs */ \ : "c" (n/4),"D" ((long) to),"S" ((long) from) \ : "cx","di","si","memory"); switch (n % 4) { case 0: COMMON(""); return to; case 1: COMMON("\n\tmovsb"); return to; case 2: COMMON("\n\tmovsw"); return to; case 3: COMMON("\n\tmovsw\n\tmovsb"); return to; } #undef COMMON } ---------------------------------------------------------------------- 리누스 토발즈 자신도 이번 루틴은 못생겼다고 말하고 있는 듯하다. C 의 case 문은 n이 0일 때는 그냥 리턴하고, 1,2,3일때는 unsigned char *, unsigned short *,로 void *를 형변환하여 포인터를 사용하여 값을 그대로 메모리로 적고 있다. void *의 유용한 점은 어떠한 포인터 형으로도 변환될 수 있다는 데 있는 데, 이것을 잘 활용하고 있는 셈이다. from과 to를 *(unsigned char *)로 값을 적는 다면 해당하는 곳에 1바이트를 적게 되고 *(unsigned short *)로 취하면 2바이트를 적게 된다. 당연히 unsigned long 을 취하면 4바이트를 적게 된다. 이 경우의 포인터에 1,2,3 등의 연산은 그 어떠한 포인터로 해당하는 주소가 참조되었느냐에 따라서, 증가하는 폭이 달 라진다. const는 from이 가르키고 있는 곳의 데이타를 상수형태로 취급함으 로써 변경을 금지함을 컴파일러에게 알리고 있다. 마찬가지로 8,12...20과 같이 적은 수에는 그냥 바로 포인터 연산으로 값을 복사한다. COMMON은 여기에서 특정부분에만 정의된다. 인라인 어셈에서 공통되는 부분 을 따로 분리하여 정의한 것이다. 내부의 인라인 어셈을 보면.. ecx에 n/4를, edi에 to를, esi에 from을 전달하고 있다. cld; rep; movsl; 로 인하여 n/4만큼 from에서 to로 4바이트 단위로 복사를 한다. 나머지 남은 여분의 1-3바이트는 define 을 적절히 활용한다. COMMAN("\n\tmovsb")는 위의 define에 의해 __asm__("cld\n\t" \ "rep; movsl" \ "\n\tmovsb" \ : .. ..... ); 로 해석이 된다. 나머지의 경우도 n%4바이트 만큼 복사를 하기 위하여 define 을 활용한다. 2.16 memmove memmove는 src에서 dest로 n바이트만큼을 메모리 이동을 시키는 것이다. memcpy와 거의 비슷하다고 볼 수 있으나 src와 dest가 겹치는 경우를 대비하여 정상적인 값을 복사한다는 점에서 조금 차이가 있다. -------------------------------------------------------------------- extern inline void * memmove(void * dest,const void * src, size_t n) { if (dest__asm__ __volatile__( "cld\n\t" "rep\n\t" "movsb" : /* no output */ :"c" (n),"S" (src),"D" (dest) :"cx","si","di"); else __asm__ __volatile__( "std\n\t" "rep\n\t" "movsb\n\t" "cld" : /* no output */ :"c" (n), "S" (n-1+(const char *)src), "D" (n-1+(char *)dest) :"cx","si","di","memory"); return dest; } --------------------------------------------------------------------- 목적지 주소 < 원천지 주소 일 경우와, 목적지 주소 >= 원천지 주소 일 경우로 나누어 처리하고 있다. 일반적으로 두개의 영역이 겹치지 않는다면 별 문제 없이 처리되지만 겹치는 경우를 예로 들어보자. 다음과 같이 그림을 그려보면, (1) dest < src <------ low address high address ------------> dest 영역 -------------------------+ | +-------------------------------------------------------------+ | dest 영역 | 겹치는 영역 | src 영역 | +-------------------------------------------------------------+ abcdefg.... |12345..... +--------------------- src 영역 이 경우에는 src의 12345부터 차례대로 dest의 abcdef...로 복사를 해 주면 별 이상없다. ecx에는 n, esi에는 src, edi에는 dest가 전달되어 cld; rep; movsb;로 정방향으로 src에서 dest로 n만큼 바이트 복사를 하게 된다. (2) src <= dest <------ low address high address ------------> src 영역 -------------------------+ | +-------------------------------------------------------------+ | src 영역 | 겹치는 영역 | dest 영역 | +-------------------------------------------------------------+ 12345... |abcde.. ..789 ...xyz +--------------------- dest 영역 이 경우에는 12345...(src)에서 abcde..(dest)로 바로 복사를 해버린 다면 복사를 채 다하기도 전에 src의 뒷부분의 값이 변경되어 버려서 정상적인 복사가 이루어 지지 않을 것이다. 이때에는 src의 뒷부분인 9,8,7 부터 dest의 뒷부분인 z,y,x로 복사를 거꾸로 하면 정상적인 복 사를 할 수 있다. ecx에 n, esi에 (n-1+(const char *)src)를, edi에 (n-1+(char *)dest )를 각각 전달하고 있다. 즉, src, dest에서 n만큼을 더한 주소를 가 르킨다. std; rep; movsb로 이번에는 거꾸로 src의 뒷부분에서 dest 의 뒷부분으로 바이트 메모리 복사가 n번 이루어진다. 2.17 memchr memchr은 strchr의 메모리 버젼이다. --------------------------------------------------------------- extern inline void * memchr(const void * cs,int c,size_t count) { register void * __res; if (!count) return NULL; __asm__ __volatile__( "cld\n\t" "repne\n\t" "scasb\n\t" "je 1f\n\t" "movl $1,%0\n" "1:\tdecl %0" :"=D" (__res):"a" (c),"D" (cs),"c" (count) :"cx"); return __res; } ----------------------------------------------------------------- cs가 가르키는 메모리에서 시작하여 c의 값이 있는지를 count번 검사 를 한다. output은 edi로 통해서 __res로 결과값이 전달되고,input은 eax에 찾고자하는 값 c를, edi에 cs를, ecx에 count를 각각 전달하고 있다. 먼저 C에서 void * __res를 선언을 하고 count가 0이라면 NULL 을 리턴한다. 아니라면 어셈블리 루틴을 실행한다. eax에는 int a의 값이 들어가 있으나 사실상은 eax의 하위 1바이트인 al만이 검사를 위해서 사용된다. cld; repne; scasb; 는 ecx(count) 번 al(a의 하위1바이트)의 값과 edi(cs)값을 비교하여 같지 않다면 계속 반복하여 같은 값이 나오면 그 다음을 edi가 가르킨다. 따라서 발견한다면 je 1f로 decl %%edi를 하여 하나를 감소시킨 다음의 메모 리 위치를 __res로 넘겨준다. 같은 값을 찾지 못했다면 movl $1, %%edi를 하여 edi에 1을 저장하고 decl %%edi로 0이 되어 __res는 NULL포인터를 리턴한다. 2. 18 memset -------------------------------------------------------------- extern inline void * __memset_generic(void * s, char c, \ size_t count) { __asm__ __volatile__( "cld\n\t" "rep\n\t" "stosb" : /* no output */ :"a" (c),"D" (s),"c" (count) :"cx","di","memory"); return s; } --------------------------------------------------------------- al(eax)에 c를, edi에 s를, ecx에 count를 전달하고 있다. cld; rep; stasb; 로 al(c)의 값을 edi(s)가 가르키는 곳에 ecx(count)번 반복 하여 쓴다. ----------------------------------------------------------------------- /* * 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.. */ extern inline void * __constant_c_memset(void * s, unsigned long c, \ size_t count) { __asm__ __volatile__( "cld\n\t" "rep ; stosl\n\t" "testb $2,%b1\n\t" "je 1f\n\t" "stosw\n" "1:\ttestb $1,%b1\n\t" "je 2f\n\t" "stosb\n" "2:" : /* no output */ :"a" (c), "q" (count), "c" (count/4), "D" ((long) s) :"cx","di","memory"); return (s); } ----------------------------------------------------------------------- eax에 unsigned long c를, eax, ebx, ecx, edx 중 하나에 count를, ecx에 count/4를, edi에 s를 전달하고 있다. 값을 전달할 때 전달되는 인자형의 크기에 따라서 commands구문에서 적절히 사용하여야 한다. 그렇지 않다면 버그가 될 수 있을 것이다. cld; rep; stosl;로 eax의 값을 edi(s)가 가르 키는 곳에 4바이트씩 ecx(count/4)만큼을 반복하여 쓴다. 이전에 본바와 마찬가지로 testb $2, %b1; testb $1, %b1; 과 같은 것으로 count의 하위 2,1번째 비트를 검사하여 각각 2바이트, 1바이트를 ax, al에서 가져와서 쓰고 있다. 2.19 strnlen ---------------------------------------------------------------------- /* Added by Gertjan van Wingerde to make minix and sysv module work */ extern inline size_t strnlen(const char * s, size_t count) { register int __res; __asm__ __volatile__( "movl %1,%0\n\t" /* ecx -> eax */ "jmp 2f\n" "1:\tcmpb $0,(%0)\n\t" /* cmpb $0, [eax] */ "je 3f\n\t" "incl %0\n" /* eax++ */ "2:\tdecl %2\n\t" /* edx-- */ "cmpl $-1,%2\n\t" /* cmpl $-1, edx */ "jne 1b\n" "3:\tsubl %1,%0" /* eax -= ecx */ :"=a" (__res):"c" (s),"d" (count)); return __res; } /* end of additional stuff */ ---------------------------------------------------------------------- output은 eax를 통해서 __res에 전달되고 있다. ecx에는 s를, edx에는 count 를 input으로 전달하고 있다. strnlen("abc", 3); strnlen("abc", 5); strnlen("abc", 2); 로 하여 각각 호출하면 3, 3, 2를 리턴한다. 즉, count안에서 s에서 널이 나오면 그 길이 를 돌려주고 나오지 않으면 count 만큼을 리턴하는 것이다. cmpb $0, (%0)은 s의 복사본 포인터를 하나 증가 시키고, incl %0은 s중 널 이 아니라면 다음 곳을 가르키게 하며 decl %2는 count의 복사본을 하나 감 소시키면서 s중 널문자를 만나거나 cmpl $=1, %2; 처럼 count의 복사본이 -1이 되면 진행된 s의 복사본에서 원래 s의 값을 빼서 돌려준다. 이것은 s의 문자열 길이이거나 count이다. 2.20 etc functions 나머지 몇개를 살펴보자. 이것도 이전의 memset과 거의 같다. 그러면서도 조금씩 다르게 작동하는 함수가 여러개이다. ----------------------------------------------------------------------- /* * This looks horribly ugly, but the compiler can optimize it totally, * as we by now know that both pattern and count is constant.. */ extern 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__("cld\n\t" \ "rep ; stosl" \ x \ : /* no outputs */ \ : "a" (pattern),"c" (count/4),"D" ((long) s) \ : "cx","di","memory") switch (count % 4) { case 0: COMMON(""); return s; case 1: COMMON("\n\tstosb"); return s; case 2: COMMON("\n\tstosw"); return s; case 3: COMMON("\n\tstosw\n\tstosb"); return s; } #undef COMMON } ----------------------------------------------------------------------- eax에 pattern을 넣고, ecx에 count/4를 넣고, edi에 s를 넣는다. 그다음 count가 적을 경우에는 그냥 바로 s에 접근하여 count 의 크기에 따라 patterns를 적고, 조금 클 경우에는 define 정의를 사용하여 어셈블 리 루틴으로 처리한다. cld; rep; stosl; 로 ecx에 저장된 횟수만큼 eax 의 값을 edi(s)가 가르키는 곳에 4바이트씩을 쓴다. 그리고 count%4의 값 에 따라 여분의 바이트를 쓰게 된다. 위에서 본바와 같다. 이번에는 memscan이다. 위에서 본 memchr과 거의 비슷하다. --------------------------------------------------------------------- /* * find the first occurrence of byte 'c', or 1 past the area if none */ extern inline void * memscan(void * addr, int c, size_t size) { if (!size) return addr; __asm__("cld repnz; scasb jnz 1f dec %%edi 1: " : "=D" (addr), "=c" (size) : "0" (addr), "1" (size), "a" (c)); return addr; } ----------------------------------------------------------------------- input은 edi에 addr을 , ecx에 size를 , eax에 찾을 값인 c를 전달한다. output은 edi를 통하여 addr로 값을 전달하고, ecx를 통하여 size에 값을 전달한다. 먼저 size가 0이면 addr을 그냥 리턴한다. cld; repnz; scasb; 로 al(c의 하위1바이트)의 값과 edi(addr)이 가르키는 곳의 값이 같은 지를 바이트 단위로 ecx(size) 번 검사하여 한다. 찾았다면 dec %%edi로 edi를 하나 감소시켜서 찾은 위치를 addr로 전달하고 못찾았다면 현재 별 의미 없는 곳을 가르키고 있는 edi를 그대로 addr로 전 달한다. ( 하이텔이 500라인이 한계라서 부득이 다음 게시물로 나머지를 적는다.) 어스름이 질녁에 ddoch 한동훈 드림