2.호출 규약

1.스택

호출 규약(Calling Convention)은 함수를 호출하는 방식에 대한 약속이다. 인수는 어떻게 전달하고 리턴값은 어떻게 반환하며 함수 호출을 위해 사용한 메모리는 누가 정리할 것인가를 규정한다. 일종의 약속이므로 양쪽이 정해진 규칙대로 보조를 맞추어야 정상 동작한다.

호출 규약은 컴파일러 내부의 일이라 함수를 사용하기만 한다면 몰라도 큰 지장이 없다. 하지만 이 과정을 이해하면 문법에 대한 자신감이 생기고 민감한 에러 상황에도 잘 대처할 수 있으며 언어간의 혼합 개발도 가능해진다.

내부를 들여다 보려면 스택을 알아야 하고 어셈블리도 개념은 있어야 하니 난이도가 꽤 높다. 스택은 CPU가 임시적인 정보를 저장하는 메모리 영역이다. 메모리를 관리하는 방식은 운영체제에 따라 다르지만 가장 일반적인 경우를 연구해 보자.

낮은 번지에 프로그램의 코드와 데이터가 있다. 두 영역은 프로그램 로드시에 할당되고 그 뒤쪽은 실행시에 할당되는 자유 영역이다. 동적 할당되는 메모리는 힙을 사용하며 아래쪽의 자유 영역으로 확장된다. 스택은 메모리의 높은 번지에 위치하여 값을 넣으면 위로 이동한다. 힙은 아래로, 스택은 위로 확장되며 자유 영역을 사용하되 두 영역이 만나면 메모리가 부족한 상태이다.

스택에 값을 저장하는 동작을 push(민다)라고 하며 저장된 값을 빼내는 동작을 pop(당긴다)이라고 한다. 스택의 현재 위치는 esp레지스터에 기억되며 push하면 esp가 감소하면서 값이 스택으로 들어가고 pop하면 esp에 저장된 값을 빼내고 esp가 증가한다. push A는 esp -= 4, mov [esp], A와 같으며 pop A는 mov A, [esp], esp += 4와 같다. 32비트 시스템에서는 스택 한칸이 4바이트이다.

스택에 저장된 값은 LIFO(Last In First Out)의 원칙에 따라 최후에 들어간 값이 먼저 나온다. 예를 들어 A, B, C 순으로 push했다면 pop할 때는 C, B, A 순으로 읽혀진다. 동전 케이스와 유사한데 아래쪽에 밀어 넣은 동전을 빼 내려면 위쪽의 동전을 먼저 빼야 한다.

CPU의 범용 레지스터는 개수가 많지 않기 때문에 필요한 레지스터가 이미 사용중이면 스택에 레지스터값을 잠시 대피해 놓고 사용한다. 예를 들어 eax, ecx를 잠시 다른 용도로 사용하고 싶다면 두 레지스터의 값을 스택에 push해 놓고 사용하다가 pop해서 복구한다.

push ecx // ecx 저장

push eax // eax 저장

eax, ecx 레지스터 사용

pop eax // eax 복구

pop ecx // ecx 복구

저장된 값을 복구할 때는 푸시한 반대 순서대로 팝한다. esp는 푸시할 때 감소하며 팝할 때 다시 증가하여 항상 다음 액세스 위치를 가리킨다.

푸시한 후 팝하면 스택은 원래 상태로 돌아간다. 그래서 푸시, 팝 회수만 맞추면 얼마든지 많은 값을 저장할 수 있으며 넣은 순서의 역순으로 꺼내기만 하면 된다. 푸시한 대상과 팝하는 대상이 반드시 일치할 필요는 없어 스택을 통해 레지스터끼리 값을 대입하거나 교환한다.

push ecx pop eax	push ecx push eax pop ecx pop eax
eax에 ecx 대입	eax와 ecx의 교환

스택에 대해 더 상세한 내용을 알고 싶다면 어셈블러 개론서를 참조하자. C언어는 스택을 직접 조작하는 방법을 제공하지 않는다.

2.스택 프레임

함수 호출시 인수, 복귀 번지, 지역변수 등이 스택에 저장되는데 함수 하나당 생성되는 일련의 정보를 스택 프레임(Stack Frame)이라고 한다. 함수 실행중에도 임시 정보를 스택에 저장하지만 푸시, 팝 회수가 항상 일치하여 스택은 언제나 항상성을 유지한다.

함수가 호출될 때 스택 프레임이 어떻게 생성되고 어떤 정보가 저장되는지 살펴보자. 어셈블리 코드를 보면 호출원에서 인수를 전달하는 방식과 함수가 값을 리턴하는 방식, 지역변수가 생성되는 영역을 들여다 볼 수 있다.

StackFrame

#include <stdio.h>

int Add(int a, int b)

{

int c, d, e;

c = a + b;

return c;

}

int main()

{

int result;

result = Add(1, 2);

printf("result = %d\n", result);

}

실행결과	result = 3

Add 함수는 두 수의 합을 구해 리턴한다. 인수, 지역변수, 리턴값을 적절히 가지고 있어 스택 프레임을 살펴보기 적절하다. Add 함수를 호출하는 부분에 중단점을 설정해 놓고 실행한 후 메뉴에서 디버그/창/디스어셈블리 항목을 선택하면 어셈블리 코드를 보여준다. 다음은 main 함수에서 Add(1,2);를 호출하는 코드이되 간략하게 요약했다.

push 2

push 1

call Add

add esp,8

result = eax

함수로 전달할 인수를 스택에 푸시한다. 뒤쪽 인수부터 순서대로 푸시한 후 call 명령으로 Add 함수를 호출한다. call 명령은 복귀할 번지를 푸시한 후 함수의 번지로 점프하는 것(push 다음번지, jmp Add)이다. 스택에는 인수 2, 1와 복귀 번지가 저장되어 있다. 다음은 Add 함수의 코드를 보자.

push ebp

mov ebp,esp

sub esp,0ch

mov eax,[ebp+8]

add eax,[ebp+0ch]

mov [ebp-4],eax

mov eax,[ebp-4]

mov esp,ebp

pop ebp

ret

Add 함수는 호출원에서 사용하던 ebp를 스택에 푸시한 후 ebp에 스택의 현재 위치를 대입한다. ebp는 인수와 지역변수를 액세스하기 위한 기준 번지(Base Pointer)로 사용되며 함수 본체에서는 계속 유지된다. Add를 호출한 함수(이 경우 main)도 ebp를 기준 번지로 사용하므로 Add는 자신의 ebp를 설정하기 전에 호출원의 ebp를 저장해야 한다.

다음으로 esp를 0ch(십진수 12)만큼 감소시켜 정수형의 지역변수 3개를 저장할 공간을 만든다. 별도의 초기화는 하지 않는다. 여기까지의 코드를 접두(prolog)라고 하며 함수의 실행을 준비하는 과정이며 이때의 스택 모양은 다음과 같다. 이 그림에서 각 격자는 4바이트이다.

ebp는 자신이 저장된 스택 위치를 가리키고 esp는 지역변수 영역의 상단을 가리킨다. esp는 필요에 따라 오르락 내리락거리지만 ebp는 계속 기준 번지를 가리킨다. ebp를 기준으로 아래쪽에는 인수가 있고 위쪽에는 지역변수가 있어 ebp에 대한 상대적인 오프셋으로 참조한다.

ebp가 가리키는 곳 바로 아래(ebp+4)에 복귀 번지가 저장되어 있으며 그 아래(ebp+8)에 첫 번째 인수 a가 있다. 본체는 [ebp+8] 표현식으로 a를 액세스하고 두 번째 이후의 인수도 오프셋만 바꾸면 된다. ebp 바로 위(ebp-4)에는 첫 번째 지역변수인 c가 있고 n번째 지역변수는 ebp-n*4에 있다. 4바이트보다 더 큰 변수는 두 칸 이상을 차지한다.

실행 준비가 완료되면 본체 코드가 실행되는데 c = a + b 코드는 다음 세 줄로 컴파일된다. 기계어는 메모리간의 덧셈을 직접 지원하지 않기 때문에 레지스터로 값을 읽은 후 레지스터와 연산한다.

mov eax,[ebp+8] // eax=a

add eax,[ebp+0ch] // eax=eax+b

mov [ebp-4],eax // c=eax

mov eax,[ebp-4] // return c

먼저 eax에 ebp+8에 있는 a를 읽는다. 여기에 ebp+0ch에 있는 b의 값을 더해 ebp-4에 있는 지역변수 c에 대입한다. 연산 결과는 리턴값을 저장하는 eax에 대입된다. 실행을 마친 후 남은 정리 작업을 수행하는데 이 코드를 접미(epilog)라고 한다.

mov esp,ebp

pop ebp

ret

esp에 ebp를 대입하여 지역변수에 할당한 스택을 회수한다. 지역변수의 생명은 이 시점에서 끝난다. ebp를 팝하면 호출원의 원래 ebp가 복구되며 ret 명령은 복귀 번지를 꺼내 리턴한다. 복귀 번지는 main 함수의 Add호출문 바로 다음이다.

add esp,8

result = eax

esp에 8을 더해 2개의 인수 전달에 사용한 메모리를 회수한다. 인수 전달 영역까지 해제하면 스택은 함수가 호출되기 전의 상태로 깜쪽같이 복구되며 esp, ebp 등의 주요 레지스터도 복구된다. 마지막으로 eax에 저장되어 있는 리턴값을 result에 대입한다.

Add 함수 하나가 호출될 때의 스택 프레임이 어떻게 작성되는지 보았는데 내부 동작이라 다분히 복잡하다. 이번에는 함수가 연속적으로 두 번 호출될 때 어떤 일이 벌어지는지 연구해 보자. 다음과 같이 Add를 호출하는 함수가 있다고 하자.

void Dog(int v)

{

int n,m;

n=Add(1,2);

....

}

Dog 함수는 정수형 인수 하나를 취하고 두 개의 정수형 지역변수를 사용한다. main에서 이 함수를 호출할 때 스택 프레임은 다음과 같이 생성된다.

최초 main만 실행중이다가 Dog가 호출되면 그 위에 Dog의 스택 프레임이 생성된다. Dog는 main이 사용하던 ebp를 저장하고 새로 설정한 ebp를 기준으로 자신의 인수와 지역변수를 액세스한다. Add가 호출되면 Add의 스택 프레임이 생성되어 인수를 전달하고 지역변수 영역을 생성한다.

Add가 다른 함수를 호출할 수 있는데 가령 gotoxy(10,20)을 호출한다면 Add의 스택 프레임 위에 gotoxy의 스택 프레임이 더 생성된다. 이런 식으로 함수가 호출될 때마다 위쪽으로 스택 프레임이 계속 쌓인다. 함수가 아무리 중첩되어도 스택의 아래쪽에는 Dog와 Add 그리고 main의 지역변수가 온전히 보관되어 있다.

Add는 리턴 직전에 지역변수 영역을 해제하고 Dog의 ebp를 복구한다. 함수별로 기준 번지가 달라 리턴하기 전에 호출원의 ebp를 복구해야 한다. Dog는 Add가 리턴된 직후에 인수 영역을 해제하여 Add가 호출되기 전의 상태로 스택을 돌려 놓는다. 마찬가지로 main은 Dog가 리턴할 때 Dog의 모든 호출 정보를 정리한다.

보다시피 함수의 모든 호출 정보가 스택 프레임에 저장되고 리턴시 원래대로 복구하여 스택은 항상성을 유지한다. 스택 공간이 남아 있는 한 얼마든지 함수를 호출할 수 있고 임의의 함수끼리 서로 호출 가능하다. 함수 호출시 스택의 동작을 살펴 봄으로써 다음과 같은 중요한 사실을 발견할 수 있다.

■ 인수는 함수 호출 중에만 생명이 유지되는 일종의 지역변수이다. 인수의 초기화 시점은 함수가 호출될 때이며 함수 내부에서만 통용된다.

■ 지역변수의 수와 함수의 실행 속도는 상관이 없다. 지역변수 영역은 esp를 필요한 양만큼 감소시켜 생성하는데 10을 빼나 20을 빼나 연산 속도는 일정하다.

■ 지역변수를 많이 쓴다고 해서 프로그램이 커지는 것도 아니다. 어차피 지역변수는 스택에 임시적으로 생겼다가 함수가 끝나면 사라지므로 프로그램의 크기와는 무관하다.

■ 지역변수를 위해 esp를 위로 올려 공간만 만들 뿐이므로 초기화되지 않으며 이때 원래 스택에 있던 값을 쓰레기값이라고 부른다. 초기식을 작성하면 쓰레기를 치워 주지만 그만큼 느려진다.

■ 함수를 호출할 때마다 스택 프레임이 생성되었다가 사라지는 복잡한 과정을 거치므로 함수 호출에는 약간의 시간이 소모된다.

컴파일러의 내부 동작을 이해하면 문법적인 사실을 자연스럽게 이해할 수 있으며 가변 인수에 대한 이해도 더 깊어진다. 이해가 깊어지면 그만큼 복잡한 상황에 대한 대처 능력도 향상되기 마련이다.

3.호출 규약

Add 함수를 통해 스택 프레임의 실제 모양을 봤는데 이는 C 언어의 기본 호출 규약인 __cdecl의 경우이다. 인수는 뒤쪽부터 전달하며 인수 전달에 사용한 스택은 호출원이 정리한다. 호출 규약은 약속일 뿐이므로 다른 형태로도 얼마든지 함수를 호출할 수 있으며 각 규약별로 스택 프레임이 달라진다. 많이 사용되는 호출 규약은 다음과 같다.

호출 규약	인수 전달	스택 정리	이름 규칙
__cdecl	오른쪽 먼저	호출원	_함수명
__stdcall	오른쪽 먼저	함수	_함수명@인수크기
__fastcall	ECX, EDX에 우선 전달. 나머지는 오른쪽 먼저	함수	@함수명@인수크기
thiscall	오른쪽 먼저, this 포인터는 ecx 레지스터로 전달된다.	함수	C++ 이름 규칙을 따름.
naked	오른쪽 먼저	함수	없음

인수 전달 방식, 스택 정리 책임, 이름 규칙 등이 각각 다르다. 리턴값 반환 방식도 다를 수 있지만 현존하는 모든 호출 규약은 eax 레지스터를 쓰는 걸로 통일되어 있다. 8바이트값은 edx:eax 쌍을 사용하며 구조체 같은 큰 값은 임시 영역에 저장한 후 eax에 포인터를 반환한다.

Add 함수의 호출 규약을 __stdcall로 바꿔 보자. __stdcall은 윈도우즈 API 함수와 비주얼 베이직이 사용하는 방식이다. __cdecl과 인수 전달 방식은 동일하되 스택을 정리하는 주체가 호출원이 아니라 함수라는 점이 다르다. Add 함수의 호출 규약을 바꾸기 위해 다음과 같이 수정해 보자.

int __stdcall Add(int a, int b)

{

int c,d,e;

c=a+b;

return c;

}

함수 이름앞에 __stdcall 키워드를 삽입하면 이 함수는 __stdcall 호출 규약을 사용한다. main에서 함수를 호출하는 부분이 다음과 같이 변경된다.

push 2

push 1

call Add

result=eax

인수를 스택에 밀어 넣는 것과 인수를 푸시하는 순서는 동일하다. 단, call Add 다음에 add esp,8 코드가 없어 함수가 리턴된 후에 인수 전달에 사용한 스택을 복구하지 않는다. 인수 전달에 사용한 영역은 이제 Add 함수가 직접 정리한다. 이 함수의 접두, 본체는 __cdecl과 동일하며 접미 부분이 다음과 같이 변경된다.

push ebp

....

ret 8

복귀 코드가 ret에서 ret 8로 바뀌었으며 복귀하면서 esp를 8만큼 증가시킨다. 이 코드에 의해 함수는 실행을 마치고 복귀함과 동시에 인수 영역을 해제한다. 함수가 스택을 알아서 정리하므로 호출원은 인수를 순서대로 스택에 푸시한 후 호출만 한다.

누가 정리하든 스택은 항상 호출전의 상태로 복귀되기 때문에 결과 코드에 큰 영향을 주지 않는다. 실행 속도는 거의 같고 프로그램 크기는 __stdcall이 약간 더 작다. __cdecl은 함수를 호출할 때마다 정리 코드가 작성되는데 비해 __stdcall은 함수 자체에 정리 코드가 딱 한 번만 작성되기 때문이다.

또 다른 차이점은 가변 인수 지원 여부이다. __stdcall은 함수가 스택을 정리하기 때문에 인수 개수가 고정적이다. 반면 __cdecl은 호출하는 곳에서 정리하므로 실제 인수 개수에 따라 정리 코드를 작성할 수 있다. printf같은 가변 인수 함수는 모두 __cdecl을 사용하며 API 함수도 wsprintf는 예외적으로 __cdecl이다. 만약 가변 인수 함수를 __stdcall로 작성하면 컴파일러는 이를 무시하고 __cdecl로 바꾸어 버린다.

다음은 함수 정의부를 int __fastcall Add(int a, int b)로 수정하여 __fastcall 호출 규약을 테스트해 보자. 호출부의 코드는 다음과 같다.

mov edx,2

mov ecx,1

call Add

result=eax

__fastcall은 인수 전달을 위해 edx, ecx 레지스터를 사용한다. 인수가 더 많으면 세 번째 인수부터는 __cdecl과 마찬가지로 스택에 밀어넣는다. 레지스터를 우선적으로 사용하여 인수 전달 속도가 빠르다. 함수의 코드는 다음처럼 작성된다.

push ebp

mov ebp,esp

sub esp,14h

mov [ebp-8],edx // 첫 번째 인수를 지역변수로

mov [ebp-4],ecx // 두 번째 인수를 지역변수로

mov eax,[ebp-4]

add eax,[ebp-8]

mov [ebp-0ch],eax // c는 세 번째 지역변수가 된다.

mov eax,[ebp-0ch]

mov esp,ebp

pop ebp

ret

edx, ecx 레지스터를 통해 전달받은 인수를 지역변수 영역에 복사하는데 어차피 인수도 지역변수의 일종이므로 이렇게 해도 별 상관이 없다. 비주얼 C++은 fastcall을 형식적으로만 지원할 뿐 fastcall의 장점을 취하지 못하는데 컴파일러 구현상 ecx, edx 레지스터가 꼭 필요하기 때문이다.

레지스터는 스택보다 빨라 __fastcall은 호출 속도가 빠르다. 대신 모든 CPU에 여유 레지스터가 항상 존재하는 것이 아니어서 이식성에는 불리하다. 그래서 윈도우즈 API는 이 호출 규약을 지원하지만 사용하지는 않는다. 볼랜드의 델파이가 __fastcall을 사용한다.

thiscall은 클래스의 멤버 함수에 대해서만 적용되는데 ecx로 객체의 포인터(this)가 전달되는 것이 특징이며 나머지 규칙은 __stdcall과 동일하다. 예외적으로 가변 인수를 사용하는 멤버 함수는 __cdecl로 작성되며 이때 this는 스택의 제일 마지막에(첫 번째 인수) 전달된다.

thiscall은 멤버 함수에 대해서만 특별히 적용하는 것이어서 일반 함수에는 적용할 수 없다. thiscall은 이 호출 규약의 이름일 뿐 키워드가 아니어서 함수 원형에 thiscall이라고 쓸 수도 없다. 멤버 함수이기만 하면 컴파일러가 알아서 thiscall 호출 규약을 적용한다.

__naked 호출 규약은 컴파일러가 접두, 접미를 작성하지 않으며 모든 것이 사용자 책임이다. 스택을 다루려면 어쩔 수 없이 어셈블리를 사용해야 하므로 일반적인 목적으로는 쓰기 어렵다. 다른 언어와 혼합 프로그래밍을 할 때나 속도가 지극히 중요한 시스템 프로그래밍에만 사용된다.

여기서 알아본 호출 규약 외에 __pascal, __fortran, __syscall 이라는 호출 규약이 있었으나 지금은 거의 사용되지 않는다. 이상으로 다섯 가지의 호출 규약에 대해 정리했는데 실제로 사용되고 사용자가 지정할 수 있는 호출 규약은 현실적으로 __cdecl, __stdcall 두 가지밖에 없는 셈이다.

4.호출 규약 불일치

컴파일러는 함수의 호출 규약에 맞게 스택 프레임을 작성하고 관리한다. 호출 규약에 따라 내부 코드가 약간 달라지고 무시해도 좋을 정도의 미세한 속도와 크기 차이가 발생하지만 실행 결과는 동일하다. 그래서 개발자가 호출 규약 때문에 고민할 필요는 없다. 호출 규약을 뭘로 지정하든 컴파일러가 함수와 호출 코드를 짝을 맞추어 만들어 준다.

하지만 함수의 언어와 호출쪽의 언어가 다를 때나 DLL의 함수를 호출할 때 등 특수한 경우에는 이를 맞춰 주어야 한다. 같은 언어에서는 호출 규약의 불일치는 발생하지 않아 한 예제에서 이런 현상을 목격하는 것은 쉽지 않다. 억지로 만들려면 함수 포인터로 호출 규약을 다르게 설정해 놓고 강제 호출해야 한다.

WrongCall

#include <stdio.h>

int __cdecl Add(int a, int b)

{

int c, d, e;

c = a + b;

return c;

}

int main()

{

int result;

int(__stdcall *pf)(int, int);

pf = (int(__stdcall *)(int, int))Add;

result = pf(1, 2);

printf("result = %d\n", result);

}

Add 함수는 __cdecl로 선언했으므로 스택 정리 책임은 호출원에 있다. main은 Add를 바로 호출하지 않고 __stdcall 호출 규약을 사용하는 함수 포인터 pf에 강제 대입한 후 호출했다. 함수 포인터는 함수를 호출하기 위한 모든 정보를 가지고 있어야 하므로 호출 규약에 대한 지정도 가진다. pf = Add라고 대입하면 타입이 달라 대입되지 않으므로 캐스팅했다.

pf는 __stdcall 호출 규약을 쓰는 함수에 대한 함수 포인터이므로 이 포인터로 함수를 호출하면 main은 스택을 정리하지 않는다. 컴파일러는 pf(1,2)호출에 대해 이 포인터가 가리키는 함수는 스택을 알아서 정리한다고 생각하여 스택 정리 코드를 작성하지 않는다. 결국 아무도 스택을 정리하지 않기 때문에 스택의 항상성이 깨진다.

스택에 저장되는 정보는 아주 중요한 역할을 하기 때문에 조금이라도 손상되면 프로그램의 동작은 예측할 수 없다. 스택 포인터를 잃어버린 프로그램은 엉뚱한 값을 레지스터에 대입하거나 복귀 번지를 잘못 찾아 임의의 메모리 번지로 점프하여 폭주해 버린다. 결국 이 프로그램은 Add가 리턴되는 즉시 다운된다.

이번에는 반대의 경우를 생각해 보자. Add 함수를 __stdcall 호출 규약으로 작성하고 main에서 pf를 __cdecl 호출 규약을 쓰는 함수 포인터로 선언한 후 pf로 Add를 호출하면 어떻게 될까? 이 경우 스택은 이중으로 정리되고 마찬가지로 스택이 깨지기 때문에 역시 다운된다. 스택은 항상성을 유지해야 한다는 대원칙을 어겼기 때문이다.

앞 장의 퀵 소트 예제로 이런 상황을 테스트할 수 있는데 compare 함수의 원형을 __stdcall로 바꾸면 당장 다운되어 버린다. qsort가 비교 함수를 호출하는 코드는 이미 라이브러리에 컴파일된 기계어 코드로 들어 있으며 qsort는 비교 함수가 __cdecl이라고 알고 있다. 그런데 다른 호출 규약으로 함수를 제공했으니 다운되는 것이 당연하다.