============================================================================ [참고]한동훈필자의 글 나는 두달동안 이문서를 끄적거려왔는 데 너무 오랫동안 질질끄는 것 같은 기분이 들어서 이제는 좀 글 쓸 기분도 들고해서 이렇게 이 문서를 내놓게 되었다. 이문서는 DJGPP를 사용해서 어셈블리코드를 작성하는 데에 대해 짧게 언급이 되어 있다. 나는 일일이 x86 어셈블리 코드를 어떻게 작성하는 지 일일이 말 하지 않을 것이다. (다른 교본이나 책을 보는 게 좋을 것이다. ). 내가 아는 한도내에서는 DJGPP에서의 인라인 어셈블리와 외부 어셈블리를 어떻게 사용하는 지 보여주도록 하겠다. 아마도 이글을 보는 분이면 TASM, MASM 등을 사용해보았거나, "표준"인텔 어셈블리에 대해 어느정도 친숙하리라고 생각한다. 내생각엔 먼저 온라인 문서인 txi*.zip 패키지 안에 들어있는 faq102.zip 과 faq201b.zip 과 같은 FAQ를 보기를 권한다. 이 문서들은 또한 comp.os.msdos.djgpp 뉴스그룹에도 있다. 주요 사이트는 DJGPP 홈페이지라고 볼 수 있는데, 최근의 업데이트 된 정보들은 DJGPP나 mail archives 에서 구할 수 있을 것이다. 필자는 mail archives에서 많은 중요한 기사들을 찾아 볼 수 있었다. ---------------------------------------------------------------------------- AT&T x86 어셈블리 문법 ====================== DJGPP는 AT&T 어셈블리 문법을 사용한다. DJGPP의 어셈블리 문법은 인텔 문법과 많은 세세한 차이점이 있다. 중요한 차이점들은 : ------------------- * AT&T 문법은 원천/목적지 피연산자들을 역으로 배치하는 데, 원천지 다음 에 목적지가 따라온다. * 레지스터 피연산자 들은 "%"를 앞에 붙인다. * 상수앞에는 "$"를 붙인다. * 메모리 피연산자들의 크기는 opcode의 끝글자로 표현된다. "b" (8-bit), "w" (16-bit), "l" (32-bit) 인텔문법과 함께 몇가지 예를 들겠다. movw %bx, %ax (mov ax, bx) xorl %eax, %eax (xor eax, eax) movw $1, %ax (mov ax,1) movb X, %ah (mov ah, byte ptr X) movw X, %ax (mov ax, word ptr X) movl X, %eax (mov eax, X) 대부분의 opcode들은 AT&T와 인텔 포멧으로 식별된다. 몇개를 제외하고는: movsSD (movsx) movzSD (movzx) S와 D는 각각 원천/목적 피연산자의 크기에 따른 접미사이다. 예를 들면 "movswl %ax, %ecx (movsx ecx, ax)". cbtw (cbw) cwtl (cwde) cwtd (cwd) cltd (cdq) lcall $S,$O (call far S:O) ljmp $S,$O (jump far S:O) lret $V (ret far V) [주의!] opcode 접두사들은 같은 라인에 쓰지 말아야 한다. 예를 들면, "rep"과 "stosd"는 두개의 명령으로 분리되어야 한다. 다른 경우는 나중에 설명하겠다. 메모리 참조하는 방법도 조금의 차이가 있다. 일반적으로 인텔에서 메모리를 참조하는 형식은 다음과 같다. 영역: [BASE + INDEX*SCALE + DISP] 이것은 다음과 같이 쓰여진다. 영역:DISP(BASE, INDEX, SCALE). 예를 몇 개 들겠다. movl 4(%ebp), %eax (mov eax, [ebp+4]) addl (%eax,%eax,4), %ecx (add ecx, [eax + eax*4]) movb $4, %fs:(%eax) (mov fs:eax, 4) movl _array(,%eax,4), %eax (mov eax, [4*eax + array]) movw _array(%ebx,%eax,4), %cx (mov cx, [ebx + 4*eax + array]) jump 명령은 항상 적은 폭의 이동으로 사용된다. 따라오는 명령들은 항상 바이트 위치이동안에서만 작동한다. "jcxz", "jecxz", "loop", "loopz", "loope", "loopnz", "loopne"들은 그렇지 않다. 온라인 문서들에서 제안한 것처럼 "jcxz foo"는 다음과 같이 쓸 수 있다. jcxz cx_zero jmp cx_nonzero cx_zero: jmp foo cx_nonzero: [주의!] "mul", "imul"명령들도 조심해서 사용해야 한다. 다중으로 확장되는 명령들은 하나의 피연산자를 사용한다. 예를 들면, "imul $ebx, $ebx" 는 그 연산결과를 "edx:eax"로 출력하지 않을 것이다. 확장된 결과를 얻을려면 "imul %ebx"처럼 하나의 피연산자를 사용하자. ---------------------------------------------------------------------------- 인라인 어셈블리 =================== 인라인 어셈블리 부터 먼저 설명하겠다. 여기에 관해서 자주 질문하는 하는 것을 보기 때문이다. 이것은 기본 문법이다. 온라인 help에서이야기한 것 처럼: __asm__(asm statements : outputs : inputs : registers-modified); 4개의 필드는: * asm statements - 뉴라인으로 구분되는 AT&T 형식 * outputs - ','에 의해서 구분되고 괄호안의 이름이 따르는 규정문 * inputs - ','에 의해서 구분되고 괄호안의 이름이 따르는 규정문 * registers-modified - ','에 의해서 구분되는 이름들 간단한 예를 들자: __asm__(" pushl %eax\n movl $1, %eax\n popl %eax" ); [주의!] 여러분들은 매번 다른 세개의 필드도 일일이 명시해줄 필요는 없다. input/output 값들을 쓸 필요가 없고 다른 레지스터를 건더릴 필요가 없다면. 입력부분을 추가해보자. int i = 0; __asm__(" pushl %%eax\n movl %0, %%eax\n addl $1, %%eax\n movl %%eax, %0\n popl %%eax" : : "g" (i) ); /* i++; */ 처음부터 차근차근 설명면, 우리의 입력값은 "i" 이고 1만큼 증가하기를 바란다고 가정해보자. 출력값은 아무것도 없는 상태이다. 레지스터를 덮어쓰지도 않는다 (먼저 "eax"를 저장을 했으므로). 그래서 두번째와 마지막 필드는 비어있다. [주의!] 입력필드외에 다른 필드를 사용하지 않는 다면, 출력필드는 공백 콜론으로 두어야 하고, 마지막 필드는 그냥 두어도 된다. 두개의 콜론사이 에는 적어도 하나의 뉴라인문자나 하나의 공백문자는 두어야 한다. 입력필드로 넘어가 보자. 규정문(constraints)는 컴파일러에게 값을 넘겨주어 다루도록 하는 명령이다. 큰따옴표로 둘러쳐야 함은 당연하다. 그렇다면 "g"는 무엇을 뜻하는가? "g"는 "i"속의 값을 어디로 불러올지를 컴파일러가 결정 하도록 하는 것이다 (어셈블리 명령어가 허용하는 한도내에서). 일반적으로 여러분들의 입력변수로 "g"를 사용하여 컴파일러가 그 값들을 어디로 취할지를 결정하도록 할 수 있다(gcc는 그것을 최적화한다). 또 범용적으로 사용되는 것으로 "r"이 있는 데 이것은 현재 사용가능한 아무 레지스터로 로딩하는 것을 의미한다. "r"에 사용되는 레지스터는 다음중의 하나이다. "a" (ax/eax), "b" (bx/ebx), "c" (cx/ecx), "d" (dx/edx), "D" (di/edi), "S" (si/esi), etc. 하나의 입력은 어셈블리 구문(첫번째필드)안에서 "%0"으로 참조될 수 있다. 두개의 입력값을 사용했다면 "%0", "%1"이 될 것이다. N개의 입력값이 있고 출력값이 없다면 "%0"에서 "%N-1"이 해당 입력값과 일치된다. [주의 !] 입력, 출력 또는 변경되는 레지스터 필드 중 어느것이라도 사용 된다면, 레지스터는 어셈블리구문(첫째필드)안에서 하나 대신 두개의 "%" 문자가 앞에 붙여져야 한다. 첫 예제에서의 규정문은 마지막 세번째 필드 에서는 사용하지 않았다. 두개의 입력을 취하고 "volatile"키워드를 도입해보자. int i=0, j=1; __asm__ __volatile__(" pushl %%eax\n movl %0, %%eax\n addl %1, %%eax\n movl %%eax, %0\n popl %%eax" : : "g" (i), "g" (j) ); /* i = i + j; */ 이번에는 두개의 입력값을 취했고 아무 문제도 없다. 단지 "%0"은 첫째 입력인 "i"와 일치하고, "%1"은 "j"와 일치하고 있다. [주의 !] "volatile"은 무엇을 뜻하는 것일까? 그것은 단지 컴파일러가 어셈블리 구문들을 다시 해석하고, 없애고, 조합하는 것을 못하게 한다. 그리고 그것을 어셈블한다. (gcc는 그것이 좋다고 느끼면 최적화를 할것이다.) 나는 "volatile"를 최근에 사용하도록 권장한다. 그리고 그것을 우리는 여기에 사용했다. 이번에는 출력 필드를 사용하는 예를 보자. int i=0; __asm__ __volatile__(" pushl %%eax\n movl $1, %%eax\n movl %%eax, %0\n popl %%eax" : "=g" (i) ); /* i++; */ 이번 예는 이전에 보았던 입력필드가 있는 예제와 거의 비슷하다. 그리고 별 큰 차이도 없다. 모든 출력 규정문은 "="가 접두어로 선행한다. 이것들은 또한 어셈블리 구문에서 "%0"에서 "%N-1" 로 참조된다. 여러분들은 입력필드와 출력 필드가 함께 사용되면 어떤 일이 일어나는 지 궁금할 것이다. 글쎄, 다음예는 두개를 같이 사용하는 것을 보여준다. int i=0, j=1, k=0; __asm__ __volatile__(" pushl %%eax\n movl %1, %%eax\n addl %2, %%eax\n movl %%eax, %0\n popl %%eax" : "=g" (k) : "g" (i), "g" (j) ); /* k = i + j; */ 여기까지는 좋다. 그러나 조금 찝찝한 것은 어셈블리 구문에 있는 숫자값이다. 설명하겠다. [주의 !] 입력필드와 출력필드를 같이 사용할때 [*** ] %0 ... %K are the outputs [*** ] %K+1 ... %N are the inputs 이번 예에서는 "%0"는 "k"를 참조하고, "%1"은 "i" 그리고 "%2"는 "j"를 참조한다. 너무 간단하지 않은가? 아직 마지막 필드인 변경되는 레지스터 (registers-modified)는 설명하지 않았다. 만일 우리가 어셈블리 구문에서 어떤 레지스터를 사용하려고 하면, "push"나 "pop"을 명시적으로 사용하거나, 아니면 그것들을 목록을 작성하여 gcc가 그것들을 보호하도록 해야 한다. 여기에 "eax"를 미리 저장하지도 않고 복귀시키지도 않는 예가 있다. int i=0, j=1,k=0; __asm__ __volatile__(" movl %1, %%eax\n addl %2, %%eax\n movl %%eax, %0" : "=g" (k) : "g" (i), "g" (j) : "ax", "memory" ); /* k = i + j; */ 변경되는-레지스터(registers-modified)에서 "eax"를 우리가 사용하므로 gcc는 그 레지스터의 값을 필요하다면 저장/복귀시킬 것이다. 16-bit 레지스터 이름은 32,16,8비트 레지스터까지도 다 커버한다. [주의 !] 우리가 만일 메모리까지도 건더리게 된다면 변경되는-레지스터(registers-modified) 필드에 "memory"를 명시하기를 권한다. 이것은 우리의 모든 예제에서 이렇게 해야 한다는 것을 뜻하나 (첫번째 예만 빼고) 나는 단순성때문에 아직까지 이것을 사용하지 않았다. 인라인 어셈블리안에 있는 지역 라벨은 "b"나 "f"로 끝나야 한다. 이것은 각각 후진 참조나 전진참조를 의미한다. 에를 들면, __asm__ __volatile__(" 0:\n ... jmp 0b\n ... jmp 1f\n ... 1:\n ... ); -------------------------------------------------------------- 외부 어셈블리 ================ 여기에 그 실마리를 제공하겠다. 몇개의 C/C++ 파일을 얻어서 "gcc -S file.c" 로 컴파일해서 file.S를 찬찬히 살펴보자. 기본적인 외양은 : .file "myasm.S" .data somedata: .word 0 ... .text .globl __myasmfunc __myasmfunc: ... ret 아~매크로, 매크로... 여기에 외부 어셈블리 파일제작을 편리하도록 돕는 include 화일을 삽입할 수가 있다. 단지 어셈블리 소스의 제일 앞쪽에 그것을 삽입시켜서 매크로를 사용하면 된다. 에를 들면 여기에 myasm.S 가 있다: #include .file "myasm.S" .data .align 2 somedata: .word 0 ... .text .align 4 FUNC(__MyExternalAsmFunc) ENTER movl ARG1, %eax ... jmp mylabel ... mylabel: ... LEAVE 이것은 외부 어셈블리 코드를 작성하는 데 좋은 골격이 될 것이다. ---------------------------------------------------------------------------- 다른 정보 ============ 이것들을 모두다 배우는 가장좋은 방법은 다른 소스를 찾아보는 것이다. "sys/farptr.h"파일에 인라인 어셈블리가 조금 있다. 또한 리눅스나 FreeBSD 등 을 사용 한다면 커널소스가 있는 곳에 (i386/ ...) 풍부한 어셈블리 코드가 있다. 그래픽/게임 라이브러리 소스가 있는 x2ftp.oulu.fi 의 djgpp2/ 디렉토리도 살펴보는 것이 좋을 것이다. 인텔 문법의 어셈블리 소스를 AT&T 문법으로 바꾸고 싶다던지 인텔 문법의 규칙을 알고 싶으면 다음과 같이 할 수 있다. * MASM을 얻어서 소스를 COFF 포맷으로 컴파일한다. (COFF는 DJGPP에서 사용되는 오브젝트 파일의 포맷이다.) * TASM을 AT&T 어셈블리로 바꾸는 ta2asv08.zip 을 구한다. * .OBJ/.LIB를 TASM과 DJGPP사이에 변환을 하는 ta2asv08.zip 을 구한다. * 인텔과 AT&T문법을 변환하는 sed 스크립트를 구하기 위해 mail archives 를 돌아다녀 본다. ---------------------------------------------------------------------------- 예제 ========= /* inline1.c -- very simple gcc inline asm example -- Compile : gcc -o inline1 inline1.c */ #include inline int plus1(int a, int b) { int __res; /* 리턴할 값 */ __asm__ ("add %%ebx, %%eax" /* ebx 값 + eax 값 ==> eax 에 저장 */ : /* 출력할 값은 없음 */ :"a" ((int)a), "b" ((int)b)); /* a의 값을 eax, b의 값을 ebx에 넘김 */ __res; /* 리턴함 */ } int plus2(int a, int b) { return (a+b); } void main(void) { int a = 222, b = 333, c = 0; c = plus1(a, b); printf("%d \n", c); c = plus2(a, b); printf("%d \n", c); }