>>> 터보 C의 깊은 곳 <<< 제3회 함수 호출의 실제와 C 호출 관행 글/임인건 (서울대 기계공학과4) --------------------------------------------------------------------- 1 본문에 앞서 --------------------------------------------------------------------- 지난 달에는 터보 C가 제공하는 6개 메모리 모델(memory model)의 구 조/특징/차이점에 관하여 설명했다. 이번에는이어서 터보 C가 제공하는 3 가지 함수 호출 방식과 더불어 함수에 매개변수를 전달하는 순서에 대하여 자세히 설명하겠다. --------------------------------------------------------------------- 2 일단 감부터 잡고 보자 - C 함수 호출의 숨겨진 내막 --------------------------------------------------------------------- 다음의 <예제 1>은 소시적의 파스칼이 코웃음칠 만한, 구석기 시대적 인 정수 합산 프로그램이다. 이 예제에서 main 함수는 sum이라는 함수를 호출한다. 이 때 sum 함수는 int형 매개변수를 2개 취하고, int형 값을 되 돌려준다. 그리고 sum 함수는 2개의 int형 자동변수를 마련하여 내부적으 로 쓰고 있다. 여기서 주의할 사항은 어떤 함수이든지 그 선언문에 나타나는 최초의 2바이트 크기(int형, unsigned형, 근거리 포인터)의 자동변수 2개는 터보 C의 최적화(optimizing)에 의해 레지스터변수로 자동 변환된다는 점이다. 이 때 레지스터변수는 터보 C 내부적으로 SI와 DI 레지스터를 의미한다. 이 점을 파악하지 못하면 <예제 2>를 이해할 수 없게 된다. 물론 그러한 최적화는다른 레지스터변수의 정의가 없을 때에 한하며, 또한 번지 연산자 &의 피연산자로 단 한 번이라도 쓰이는 2바이트 크기의 자동변수는 순서상 비록 최초일지라도 레지스터변수로 자동 변환되지 않는 다. 그것은 레지스터변수의 경우 그 번지를 취할 수 없기 때문이다. <예제 1> 아주 간단한 예제 --------------------------------------------------------------------- #include int sum(int n1, int n2) { +--+------------ 최적화에 의해 자동적으로 int n; | 레지스터 변수(SI와DI)가 된다. int sum = 0; --- 함수명과 자동변수명은 중복되도 무방하다. for (n = n1; n <= n2; n++) sum += n; return sum; } void main(void) { int result; result = sum(0, 10); printf("Result = %d\n", result); } --------------------------------------------------------------------- 다음의 <예제 2>는 tcc.exe를 써서 <예제 1>을 어셈블리로 컴파일한 뒤에 중요한 부분만 발췌/편집한 것으로서, 터보 C에서 함수를 호출하고 값을 복귀(return)하는 이른바 "호출 관행(calling convention)"의 전말을 보여 주고 있다. 즉 함수 호출/피호출 규칙 및 매개변수의 전달 순서 등이 적나라하게 드러나 있다. 이미 어셈블리에서의 함수(프로시져) 호출 방식 등에 익숙해 있는 독자는 <예제 2>만으로도 몇 달 분량의 원고를 다 읽은 셈이 될 것이다. <예제 2> <예제 1>을 어셈블리로 컴파일한 코드 --------------------------------------------------------------------- ...... ; ; sum 함수(PUBLIC 선언은 다른 곳에 모아져 있다) ; _sum PROC near --- 근거리 함수임을 나타낸다. 진입 +-push bp --- BP를 대피시킨다. 코드 +-mov bp,sp --- BP는 매개변수와 자동변수를 참조하기 위한 포인터로 쓰인다. push si -+- 함수 내에서 SI와 DI를 쓰려면 반드시 push di -+ SI와 DI의 이전 값을 대피시켜야 한다. xor di,di --+ mov si,word ptr [bp+4] | jmp short @5 매개변수n1 | @4: | sum 함수 블럭 내의 add di,si | 문장들을 컴파일한 @3: | 어셈블리 코드 inc si | @5: | cmp si,word ptr [bp+6] | jle @4 매개변수n2 -+ @2: mov ax,di --- 2바이트 크기의 데이터형은 jmp short @1 AX에 넣어 복귀한다. @1: pop di -+- SI와 DI의 이전 값을 복구 pop si -+ 탈출 +-pop bp--- BP의 이전 값을 복구 코드 +-ret _sum ENDP ; ; main 함수 ; _main PROC near +-- 함수 내부에서 SI를 쓰므로 push si ----+ 이전 값을 대피시킨다. (main 함수도 기동 코드에 대한 피호출 함수임) +-mov ax,10 | push ax ------- 두번째 실매개변수 10의 저장 sum | xor ax,ax ---- 첫번째 실매개변수 0의 저장 호출 | push ax ------- 근거리 호출(near call) | call near ptr _sum | pop cx -+----- SP의 원상 복귀 +-pop cx -+ (pop 명령을 썼음에 주목) mov si,ax --- 반환값을 result(즉 SI)에 대입 +-push si 문자열 "Result = %d\n"을 가리키는 printf| mov ax,offset DGROUP:s@ --+ 포인터 호출 | push ax +--- 다음 달에 설명할 예정 | call near ptr _printf | pop cx +-pop cx pop si -------- 이전 값을 복구 ret --------------- 프로그램의 실행을 종료한다 _main ENDP (실제로는 기동 코드의 종료 루틴으로 프로그램 제어를 넘긴다) ...... --------------------------------------------------------------------- --------------------------------------------------------------------- 3 호출 함수와 피호출 함수의 의미 --------------------------------------------------------------------- 본론에 들어가기 전에 우선 새로운 용어 두 가지만 확실히 하고 넘어 가자. <예제 1>를 보면 main 함수가 sum 함수를 호출하고 있다. 여기서 그 호출한 시점에서만 국한하여 볼 때, main 함수를 "호출 함수"라고 하고 su m 함수를 "피호출 함수"로 부르기로 하자. 굳이 영어로 하자면 각각 "call ing function", "called function"이 되겠다. 유의할 점은 호출 함수와 피호출 함수의 관계가 그 호출하는 시점에 국한되어 결정지어진다는 것이다. 그래서 시점을 바꾸면 그 관계도 달라진 다. 예를 들어 만약 sum 함수가 또 다른 함수를 호출한다면 그 시점에서는 sum이 호출 함수가 된다. 그리고 main 함수도 프로그램 실행 직후로 시점 을 달리 하면 기동 코드(startup code)에서 호출되는 피호출 함수이다. 그 밖에 복귀(return), 대피(push), 복구(pop), 반환값(리턴값; retur n value) 등의 용어도 생소한 독자는 익혀 두기 바란다. --------------------------------------------------------------------- 4 근거리/원거리/거대 함수 --------------------------------------------------------------------- 4.1 C와 어셈블리의 링크에 앞서 한편, <예제 2>를 훑어보고 "대충 그런거구나!"하고 이해가 간다면 곧 바로 이 글의 최종 목표인 C와 어셈블리의 링크에 관한 이야기를 풀어도 무리가 없겠지만, 논리의 흐름을 위해 일단은 함수 호출 방식을 비롯한 제 반 사항에 대한 설명이 먼저 있어야 할 것 같다. 우리는 C로 프로그램을 짤 때 함수명 다음에 괄호를 두르고 실매개변 수들을 나열하면 C 컴파일러가 그 함수를 알아서 적당한 방법으로 호출해 주므로 실제로(어셈블리어 수준에서) 함수가 어떻게 호출되는지는 사실상 알 필요가 없었다. 하지만 C와 어셈블리를 링크하려면 그 호출 방법을 모 르고서는 함수를 호출할 수가 없다. 왜냐 하면 어셈블리 루틴은 C 컴파일 러와 별개의 존재이기 때문이다. 여담이지만... 우리가 숟가락으로 밥 한 술을 뜰 때 과연 어떻게 하고 있는지 생각해 보고 먹는 사람이 있는가? 숟가락을 쥘 때에 얼마마한 압 력을 가해야 숟가락이 미끄러 떨어지지 않고, 숟가락을 몇 뉴튼의 힘으로 어떤 방향에서 밥풀 더미에 쑤셔 넣어야 숟가락이 밥풀 더미의 저항으로 이기고 파고들 수 있는가, 그리고 손목에 얼마 만한 모멘트를 가해야 숟가 락이 밥을 퍼낼 수 있으며, 팔과 손목을 몇 자유도로 어떠한 경로로 얼마 만한 속도로 이동시켜야 최단 시간 내에 퍼낸 밥을 단 한 톨 흘리지 않고 목적지인 입에 접근시킬 수 있는가... 게다가 그런 동작을 취하기 위해 대 뇌에서 각 조직의 신경 섬유에 어떠한 전기적 펄스를 가해야 하느냐에까지 다다르면 정말 밑도 끝도 없다. 이런 걸 생각해 본 적이 있는가 말이다. 물론 거의 전무하겠지. 사람이라면 그런 건 본능적으로 "자연스럽게" 처리 할 수 있을 테니 당연하다. 하지만 만약에 밥 한 술을 뜨는 로보트 팔을 만든다고 해보라. 아니면 시뮬레이션도 좋다. 그렇다면 얘기는 전혀 달라질 것이다. 왜냐 하면 로보 트는 본능이란 게 없으니깐. 그러므로 좀 전에 언급한 모든 것이 심각한 고려 대상이 된다. 결론적으로 봐서 그 밥 한 술 뜨는 어찌보면 하찮고 간 단한 동작을 해석하기 위하여 수십 수백명의 천재가 동원되어야 할 것이 다. 이것을 C와 어셈블리의 관계에서도 그럴 듯하게 비유된다. C 언어로 프로그래밍할 때에는 내부적인 복잡한 처리를 C 컴파일러가 알아서 "자연 스럽게 해결(컴파일)"해 주므로 전혀 대수롭지 않게 생각되던 것이, 어셈 블리로 할 때에는 하나부터 열까지 모든 것을 프로그래머가 책임지고 해 나가야 한다. 따라서 발생하는 어려운 일이 한두 가지가 아니다. 반드시 준수해야 할 규칙도 부지기수이고, 또한 벌레잡는 데(디버깅) 드는 고충도 이만저만이 아니다. 이런 점을 염두에 두고, C와 어셈블리의 링크에는 이처럼 어려운 일이 산적해 있다는 것을 미리 파악한 뒤에 이 글을 읽어 나간다면, 세세하고 쪼존한 수많은 규칙들을 익히는 데 드는 부담감은 어느 정도 줄일 수 있으 리라 본다. 4.2 근거리 호출(near call) 먼저 가장 간단하고 가장 일반적인 근거리 호출에 관하여 알아보자. 근거리 호출의 가장 특징적인 점은 피호출 함수(근거리 함수)가 본연의 임 무를 성공리에 마치고 원래 자신을 호출했던 함수로 복귀(리턴)할 때, 스 택으로부터 "2바이트의 복귀 번지"를 취한다는 것이다. 어셈블리 코드로 이를 나타내면 다음과 같다. * 근거리 함수(near function)의 정의 PUBLIC _func _func PROC near ← 근거리 함수임을 표시 ...... ret --- 2바이트의 복귀 번지(IP)를 취한다. _func ENDP * 근거리 호출(near call) call near ptr _func | +-- 스택에 2바이트의 복귀 번지만을, 즉 IP만을 대피시킨다. 4.3 원거리 호출(far call) 그 다음으로 원거리 호출의 가장 특징적인 점은 피호출 함수(원거리 함수)가 일을 모두 끝마치고 복귀할 때, 스택으로부터 "4바이트의 복귀 번 지"를 취한다는 것이다. 어셈블리 코드로 이를 나타내면 다음과 같다. * 원거리 함수(far function)의 정의 PUBLIC _func _func PROC far --- 원거리 함수임을 표시 ...... ret ---4바이트의 복귀 번지(CS:IP)를 취한다. _func ENDP * 원거리 호출(far call) 같은 모듈 내의 함수 호출시 ← 작은 글자체!! push cs call near ptr _func 다른 모듈 내의 함수 호출시 ← 작은 글자체 call far ptr _func | +-- 스택에 4바이트의 복귀 번지를, 즉 CS:IP를 대피시킨다. (주의)위의 호출 방식이 아래보다 처리 속도가 빠름. 그러나 결과는 완전히 동등함. 4.4 거대 호출(huge call) 거대 호출은 함수 호출 방법에 관한 한 사실상 원거리 호출과 완전히 동일(identical)하다. 더욱이 어셈블리 수준에서는 "문법적으로" 원거리 호출과 거대 호출이 전혀 구별되지 않는다. 다만 원거리 호출과의 차이점이라면 피호출 함수(거대 함수)가 그 선 두에서 DS의 값을 일단 대피시킨 후에, 자신이 속해 있는 모듈의 정적 데 이터 영역 선두로 DS를 변경한다는 것이다. 그런 후 일을 모두 끝마치면 원래의 DS 값을 복구한 다음 4바이트의 복귀 번지(CS:IP)를 취하여 되돌아 간다. 이처럼 DS가 고정적이지 않기 때문에 터보 C의 6개 메모리 모델 중 에서 유일하게 64k 이상의 정적 데이타를 취할 수 있는 모델이 되는 것이 다. 어셈블리 코드로 이를 나타내면 대략 다음과 같은데, 거대 함수는 어 셈블리와의 링크에서는 실제로 거의 쓰이지 않을 것이므로 그런데 있구나 하는 정도로만 알아 두면 될 것 같다. * 거대 함수의 정의(작성) PUBLIC _func _func PROC far ...... push ds mov ax, 모듈명_DATA mov ds,ax | ...... +-- 해당 모듈의 정적 데이터 영역의 pop ds 선두를 가리키는 포인터. ...... ret _func ENDP * 거대 호출(원거리 호출과 완전히 동일) 같은 모듈 내의 함수 호출시 push cs call near ptr _func 다른 모듈 내의 함수 호출시 call far ptr _func --------------------------------------------------------------------- 5 근거리/원거리/거대 함수의 선언(정의) --------------------------------------------------------------------- 5.1 함수 수식자 near/far/huge 지금까지는 어셈블리 코드로 예를 들었는데 C 문법적으로도 근거리/원 거리/거대 함수를 선언 및 정의할 수 있다. 그 방법도 간단해서, 함수 선 언 또는 정의에서 void, int, double 따위의 함수형 지정자(type specifie r)와 함수명 사이에 near/far/huge라는 함수 수식자(function modifier) 중의 하나를 삽입하는 것으로 끝난다. 예를 들어 <예제 1>의 sum 함수를 원거리 함수로 정의하려면 아래와 같이 바꾸면 된다. 다른 모든사항은 평상시와 똑같다. * 원거리 함수의 정의 int far sum(int n1, int n2) { ...... } * 원거리 함수의 선언 int far sum(int n1, int n2); 일반적인 경우에 near/far/huge 등의 함수 수식자는 쓸 일이 거의 없다. 그것은 메모리 모델에 따라서 적절한 함수 호출 방식이 내정되기 때문이 다. 자세한 사항은 저번 달에 지루하도록 자세히 설명한 바 있으므로 새삼 스럽게 재론하지는 않겠다. 다만 대형 코드 모델에서 속도상의 문제로 인해 특별히 근거리 함수가 필요할 할 때 near를 쓰기도 하고, 반면에 터보 C가 제공하는 그래픽 함수 들과 같이 소형 코드 모델에서도 반드시 원거리 호출을 해야만 하는 경우 에 그 선언문 등에 far를 기술하기도 함을 참고하기 바란다. 지금 당장 터 보 C 참조 안내서(매뉴얼)를 보기 바란다. 아마 그래픽 함수는 몽땅 그 원 형에 far 수식자를 포함하고 있을 것이다. 덧붙여서 그래픽 함수는 메모리 모델에 상관없이 단 한 벌만이 마련되 어 있기 때문에 호환성을 위해 모두 원거리 함수로서 작성되어 있다. 5.2 선언/정의할 때 주의할 점 한편, 주의할 점은 반드시 함수명 직전에 near/far/huge를 삽입해야 한다는 것이다. 다른 곳에 삽입하면 수식자의 의미가 전혀 틀려진다. 예를 들어 아래의 세 선언문은 서로 완전히 다른 의미를 가지고 있다. [1] char *far func1(void); [2] char far *func2(void); [3] char far *far func3(void); | | | +-- func3가 원거리 함수임을 나타내는 | 함수 수식자(function modifier) +-- func3의 반환값이 원거리 포인터임을 나타내는 번지지정 수식자(addressing modifier) 위의 선언들은 각각 아래와 같은 의미를 가지고 있다. [1] (내정된 크기의) char *형 포인터를 복귀하는 원거리 함수 func1을 선 언 [2] char far *형 포인터를 복귀하는 (내정된 호출 방식의) 함수 func2를 선언 [3] char far *형의 포인터를 복귀하는 원거리 함수 func3를 선언 여기서 "내정된 크기"란 소형 데이터 모델에서는 근거리 포인터, 그 밖에는 원거리 포인터로 내정됨을 뜻하고, "내정된 호출 방식"이란 소형 코드 모델에서는 근거리 함수, 거대 모델에서는 거대 함수, 그 밖에는 원 거리 함수임을 뜻한다. 세 가지 선언이 잘 구별되지 않는다면, 책을 잠시 덮어 두고 장마로 우중충한 하늘이나마 한번 물끄러미 쳐다본 뒤에 저번 달 글부터 차분히 다시 읽어 보면 자연스럽게 이해가 되리라 본다. #51 임인건 (turbo28 ) [강좌] C깊은곳3-2: 함수 호출/C 호출 관행 05/06 00:13 437 line --------------------------------------------------------------------- 6 매개변수 전달 방식 2가지의 개요 --------------------------------------------------------------------- 이상에서는 함수의 호출/복귀라는 관점에서 주로 설명을 진행했다. 이 번에는 함수를 호출할 때 과연 실매개변수(actual parameter 또는 argumen t)를 어떠한 순서로 스택에 대피(저장)시키느냐 하는 관점에서 설명을 하 겠다. 참, 함수에 매개변수를 전달하는 방법으로서 거의 대부분의 고급 언 어에서 스택이 활용된다는 것쯤은 익히 알고 있으리라 믿는다. 피호출 함수에 매개변수를 전달하는 순서는 아래와 같이 딱 2가지 방 법에 의한다. +----------------------------------------+ | [1] C 방식 매개변수 전달 순서 | | C Parameter-Passing Sequence | | 또는 C 호출 관행 | | C Calling Convention | | | | [2] 파스칼식 매개변수 전달 순서 | | Pascal Parameter-Passing Sequence| | 또는 파스칼 호출 관행 | | Pascal Calling Convention | +----------------------------------------+ 이 중에서 후자는 터보 파스칼같은 고급 언어와의 링크에서나 필요한 것이므로 지금 당장은 알아 둘 필요가 없다. 반면에 전자는 터보 C(사실상 IBM-PC에서 돌아가는 대부분의 C)가 표준 라이브러리 함수들을 비롯한 모 든 함수의 호출할 때의 내정(default)된 방식이므로, C와 어셈블리의 링크 를 위해선 전자의 방식을 학실하게 파악해 둘 필요가 있다. 이 두 방식간의 가장 큰 차이점은 첫째, 실매개변수를 스택에 저장하 는 순서이고 둘째, 복귀 후에 스택 포인터 SP값의 복구를 호출 함수와 피 호출 함수 중 어느 쪽이 담당하느냐 하는 것이다. 두번째 사항은 곧 매개 변수의 갯수가 필요에 따라 가변적일 수도 있느냐 아니면 항상 고정적이냐 하는 것을 의미하기도 한다. 추가로 아주 근소하고 보통 무시할 수 있는 호출/복귀 처리 속도의 차이도 있다. 그러면 이제부터 C 방식 매개변수 전달 순서에 대하여 차분히 알아보 기로 하자. --------------------------------------------------------------------- 7 C 방식 매개변수 전달 순서 - C 호출 관행 --------------------------------------------------------------------- 예를 들어 아래와 같은 원형(prototype)을 가진 함수가 정의 및 선언 되어 있다고 치자. 여기서 함수 본체(body)는 아무래도 상관없다. 주목할 것은 매개변수의 전달 방식이나까. void funca(int p1, int p2, long p3); 내정적으로 터보 C는 C 방식 매개변수 전달 순서에 의한다. 이는 다른 말로 "C 호출 관행"이라고도 흔히 일컫는다. 위의 함수 funca가 다음과 같 이 호출되었을 때, void main(void) { funca(0x1122, 0x3344, 0x55667788); } 호출 함수(즉 main)쪽의 각 실매개변수 0x1122, 0x3344, 0x55667788은 "모 두" 스택에 대피(저장)된다. 이 때 대피 순서는 "오른쪽->왼쪽"임에 유의 하기 바란다. 그런 다음에 마지막으로 복귀 번지(return address)가 스택 에 대피된 후 funca로 프로그램 제어가 옮겨진다. 자, 그런 연후에 스택은 어떻게 되었을까? 즉 복귀 번지가 대피된 " 직후"에 말이다(복귀 번지가 대피된 이후에도 호출 규칙에 따른 추가적인 대피가 계속해서 이어지므로 유의할 것). <그림 1-1> 근거리 호출시 스택의 내용 --------------------------------------------------------------------- 상위 번지 대피 순서 | | SP + 8: 0x5566 -+- 세번째 실매개변수 | | SP + 6: 0x7788 -+ | | SP + 4: 0x3344 --- 두번째 실매개변수 | | SP + 2: 0x1122 --- 첫번째 실매개변수 | | SP + 0: 복귀 번지(2바이트) 하위 번지 --------------------------------------------------------------------- <그림 1-2> 실제 스택의 상황(바이트 단위의 구조) --------------------------------------------------------------------- SP SP+2 SP+4 SP+6 SP+8 +----------+---+---+---+---+---+---+---+---+ | 복귀번지 | 22| 11| 44| 33| 88| 77| 66| 55| +----------+---+---+---+---+---+---+---+---+ --하위 번지 상위 번지-- --------------------------------------------------------------------- <그림 1-3> 실제 스택의 상황(워드 단위의 구조) --------------------------------------------------------------------- SP 0x55667788 +-------------+ +----------+-------+-------+-------+-------+ | 복귀번지 | 0x1122| 0x3344| 0x7788| 0x5566| +----------+-------+-------+-------+-------+ --하위 번지 상위 번지-- --------------------------------------------------------------------- <그림 2> 원거리/거대 호출시 스택의 내용 --------------------------------------------------------------------- 상위 번지 대피 순서 | | SP + 10: 0x5566 -+- 세번째 실매개변수 | | SP + 8: 0x7788 -+ | | SP + 6: 0x3344 --- 두번째 실매개변수 | | SP + 4: 0x1122 --- 첫번째 실매개변수 | | SP + 0: 복귀 번지(4바이트) 하위 번지 --------------------------------------------------------------------- 여기서 주의할 점은 첫째, 스택은 상위 번지쪽에서 하위 번지쪽으로 성장(SP가 감소)한다는 것이고 둘째, 8086계 CPU인 탓에 2바이트 이상의 크기를 가지는 데이타는 역워드(reverse word) 방식에 의해 항상 하위 바 이트부터 메모리에 차례대로 저장된다는 점이다. 따라서 4바이트 크기의 실매개변수인 0x55667788은 <그림 1-2>에서와 같이 0x88, 0x77, 0x66, 0x5 5의 순으로 메모리에 저장되니 착오없기 바란다. 자, 이제 C 호출 관행에서 또 하나의 중요한 사실을 설명하겠다. 그것 은 바로 "피호출 함수는 스택에 대피되어 있는 실매개변수의 개수를 전혀 알 수가 없다"는 점이다. 즉 원칙적으로 불가능하다. 대신에 피호출 함수의 입장에서는 "필요한 만큼의 실매개변수가 대피 되어 있다"고 가정할 수밖에 없다. 바꿔 말하면 실매개변수가 형식매개변 수의 개수보다 모자라거나 남아돌더라도 피호출 함수는 딱 맞는 개수만큼 이 있다는 가정하에서 모든 일을 처리한다. 이는 C 호출 관행의 경우 피호출 함수가 아닌 호출 함수 쪽에서 SP의 복구를 담당하기 때문에 파생되는 결과이다. 즉 스택에 대피되어 있는 실 매개변수들만큼의 복구(pop)를 호출 함수 쪽에서 담당한다. 다음 <리스트 2>의 맨 마지막 행에 있는 add sp,8 명령에 주목하기 바란다. <리스트 2> funca를 호출하는 어셈블리 코드 --------------------------------------------------------------------- mov dx,21862 --- 0x5566 mov ax,30600 --- 0x7788 push dx --+------- 마지막 실매개변수를 대피 push ax --+ mov ax,13124 --- 0x3344 push ax ---------- 두번째를 대피 mov ax,4386 --- 0x1122 push ax ---------- 첫번째를 대피 call near ptr _funca add sp,8 --- pop을 4번 행한 것과 같은 효과를 가져온다. --------------------------------------------------------------------- <리스트 2>를 보면 스택의 복구를 호출 함수 쪽(main 함수)에서 담당 한다는 것을 눈으로 확인할 수 있을 것이다. 말을 바꾸면 스택의 복구를 피호출 함수 쪽에서 행하면 절대로 안 된다고도 할 수 있다. 파스칼에서 어셈블리 링크를 해본 독자는 헷갈리지 않도록 특히 조심해야 한다. 즉 re t 명령에 숫자를 지정하면 절대로 안 된다. 참고로 스택을 복구할 때 pop 명령을 4번 쓰는 대신 add sp,8을 쓴 것 은 처리 속도상의 이점 때문이다. <리스트 1>에서 add sp,4 대신에 pop 명 령을 두 번 쓴 것도 같은 이유에서다. <표 1> C 호출 관행과 파스칼 호출 관행의 차이점 -----------------+------------------+-------------------- | C 호출 관행 | 파스칼 호출 관행 -----------------+------------------+-------------------- 매개변수 | 오른쪽에서 왼쪽 | 왼쪽에서 오른쪽 전달 순서 | (마지막부터) | (첫번째부터) | | 스택의 복구 | 호출 함수가 담당 | 피호출 함수가 담당 | | 매개변수의 개수 | 가변적일 수 있음 | 항상 고정적 -----------------+------------------+-------------------- --------------------------------------------------------------------- 8 반환값(return value)의 처리 --------------------------------------------------------------------- 피호출 함수가 일을 마치고 복귀할 때 반환값은 과연 어떠한 방식으로 자신을 호출한 함수에 되돌려 줄까? 그것은 아래와 같은 규칙에 의한다. --------------------------------------------------------------------- [1] 2바이트 크기 이하의 데이터형: AX에 저장한다. char, unsigned char, int, unsigned, enum, 근거리 포인터 등 [2] 4바이트 크기의 데이터형: DX:AX에 저장한다. (DX에 상위 2바이트를, AX에 하위 2바이트를) long, unsigned long, 원거리 포인터, 거대 포인터 등 [3] 부동형: 80x87의 TOS 레지스터, 즉 ST(0)에 저장한다. 단, 80x87을 에뮬레이트하는 경우 에뮬레이터의 TOS 레지스터에 저장한다. float, double, long double 등 [4] 구조체/공용체를 통채로 리턴하는 경우: 따로 전용으로 마련된 정적 데이터 영역에 결과를 저장한 다음 그 영역을 가리키는 포인터를 AX 또는 DX:AX에 넣어 되돌여 준다. --------------------------------------------------------------------- 대개의 경우 어셈블리와의 링크에서 주로 쓰이는 것은 아무래도 [1]번 또는 [2]번 방식이며, <예제 2>에서는 [1]번 방식을 확인할 수 있다. --------------------------------------------------------------------- 9 함수명에 덧붙는 밑줄문자의 의미 --------------------------------------------------------------------- 지금까지의 예제들을 보면 C 원시 코드의 함수명에는 안붙던 밑줄문 자가 어셈블리 코드의 함수명 앞에 덧붙여져 있는 것을 확인할 수 있을 것 이다. 예를 들어 main 함수의 어셈블리 코드에는 그 함수명이 _main으로 되어 있다. 사실 터보 C에서는 함수명이 어셈블리 코드로 컴파일될 때에 항상 그 앞에 밑줄문자가 덧붙여지도록 되어 있다. 그 이유는 볼랜드에서 공식적으 로 발표한 바 없으나, 추측컨대 터보 C의 내부 루틴이 직접적으로 호출되 는 것을 막기 위한 것으로 보인다. objxref.exe 유틸리티를 써서 터보 C 표준 라이브러리를 뒤적거려 보 면 대소문자가 마구 섞여 있는 괴상한 이름의 함수(실제로는 정식 함수도 아님)들이 많이 보이는데 이들은 대부분 선두에 밑줄문자를 가지고 있지 않다. 그것은 속도/크기 문제로 인해 C 호출 관행을 지키지 않은 일종의 어셈블리 서브루틴이기 때문이다. 따라서 이들을 C쪽에서 직접 호출하면 프로그램이 폭주하게 되므로 그러지 못하도록 모든 C 함수명에는 자동적으 로 선두에 밑줄문자가 덧붙도록 한 것 같다. 물론 컴파일러 옵션을 조정하면 밑줄문자를 제거할 수도 있지만, 그것 은 터보 파스칼과 링크할 때에나 필요한 조치이므로 자세한 설명은 생략하 겠다. --------------------------------------------------------------------- 10 소형 모델에서의 메모리 지도 --------------------------------------------------------------------- 지난 달에 소개했던 메모리 지도 예제에 대한 설명을 계속하자면 다음 과 같다. * 변수 설명(소형 모델에 해당하는 내용임!!) _heaplen: 근거리 힙의 바이트 크기를 나타낸다. 0의 값을 가지면 데이 터 세그먼트의 크기가 정확히 64k바이트가 되도록 근거리 힙 의 크기가 자동으로 결정된다. 따라서 근거리 힙의 최소 크기 는 1바이트가 된다. _stklen: 스택 영역의 바이트 크기를 나타낸다. 내정치는 4k바이트(409 6)이다. 그러나 이 변수가 스택의 크기를 4k바이트로 제한하 지는 못한다. 예를 들어 4k바이트가 넘는 자동배열을 정의해 도 실행시 에러가 나지 않는다. 다만 _heaplen과 함께 데이터 세그먼트의 크기를 결정하는 데 쓰인다. _psp: PSP의 세그먼트값을 가진다. PSP에 관한 설명은 지면상 생략 하겠다. 다만 옵셋 0x0002의 위치에 메모리 최상단의 세그먼 트값(640k 시스템에서는 0xa000)이 저장되어 있다는 것만 알 아 두면 프로그램을 이해하는 데에는 별 지장이 없을 것이다. __heapbase: 근거리 힙의 최하위 번지(즉 베이스)를 가리키는 포인터이다. 말을 바꾸면 정적 데이터 영역 직후를 가리키는 포인터라고도 할 수 있다. __heaptop: 근거리 힙의 현재 최상단을 가리키는 포인터이다. 프로그램 실행 직후에는 동적으로 근거리 힙이 할당된 것이 하나도 없을 터이므로 __heapbase와 동일한 값을 갖는다. _heapbase: 원거리 힙의 최하단을 가리키는 원거리 포인터이다. 원거리 힙은 항상 세그먼트 경계에서 시작하며, 또한 _heapbase는 정 규화되어 있으므로 그 옵셋(하위 2바이트)은 항상 0x0000이 다. _heaptop: 원거리 힙의 최상단을 가리키는 원거리 포인터이다. 주의할 사항은 __heaptop과는 달리 _heaptop은 메모리의 최상단을 가 리킨다는 점이다. 따라서 640k바이트 시스템에서는 항항 A00 0:0000의 값을 갖게 된다. 참고로 __heapbase, __heaptop, _hearbase, _heaptop 등은 터보 C 매 뉴얼에 설명되어 있지 않으며, _heaplen, _stklen, _psp는 Turbo C Refere nce Guide의 28, 30, 29쪽에 상세히 설명되어 있다. 또한 매뉴얼에 설명되어 있지는 않지만, _heaplen과 _stklen 변수에 값을 지정할 때에는 <예제 3>처럼 반드시 외부변수의 초기화 형식이어야 하는데 주의하기 바란다. 프로그램 실행 후 어떤 값을 대입하는 것은 아무 의미도 없다. 그것은 그 변수들을 참조하는 루틴이 main 함수가 호출되기 이전의 기동 코드(startup code)이기 때문이다. * 소형 데이터 모델에서 데이터 세그먼트의 크기를 결정하는 공식 void *ptr; unsigned DSsize; --- 패러그래프 단위의 크기 if (_heaplen == 0) DSsize = 0x1000; --- 환산하면 65536바이트 else { ptr = (char *)__heapbase + _stklen + _heaplen; DSsize = ((unsigned)ptr >> 4) + 1; } 참고: 이 공식은 기동 코드 c0.asm을 분석해서 얻은 것임. * 램상주 프로그램(초소형 또는 소형 모델)에서 상주 크기(keep size)를 구하는 공식 2가지 +- unsigned keepsize; --- 상주 크기 +- unsigned CSsize; --- 코드 세그먼트의 크기 | +----------------------- 패러그래프 단위 keepsize = FP_SEG(_heapbase) - _psp; --- 가장 간단한 공식 (모든 모델에서 통용) 또는(초소형/소형 모델에서) CSsize = _DS - _CS; --- 초소형 모델에서는 항상 0 keepsize = 0x10 + CSsize +DSsize; | +-- PSP의 크기 위의 상주 크기는 램상주 프로그램에서 아래와 같이 쓰인다. keep(0, keepsize); 만약 _heaplen이 0(내정치)이라면 데이터 세그먼트의 크기가 65536바 이트로 결정되므로 구태여 복잡한 공식 쓸 필요 없이 간단하게 keep(0, 0x 1000)이라고 해도 된다. <예제 3> 소형 메모리 모델의 메모리 지도 --------------------------------------------------------------------- /* File MEMMODEL.C */ #include #include #include #pragma warn -par /* off warning */ unsigned _heaplen = 0x0001; /* minimum value */ /* if _heaplen == 0 or _heaplen is too large, this program will output wrong results */ unsigned _stklen = 0x0250; /* minimum value is 0x0200 when the software emulation for the floating point operation */ extern unsigned _psp; /* program segment prefix */ /* declared in dos.h */ extern void *__heapbase; /* a pointer to the near heap base */ extern void *__heaptop; extern void far *_heapbase; /* a pointer to the far heap base */ extern void far *_heaptop; void main(int argc, char *argv[], char **env) { unsigned CSsize; /* code segment size in paragraph(small model) */ unsigned DSsize; /* data segment size in paragraph */ unsigned StartingSP; /* initial value of SP */ unsigned farheap; /* segment of the far heap base pointer */ unsigned keepsize; /* calculated keep size in paragraph, i.e. total program size */ void *ptr; void far *topofmem; /* far pointer to the top of the memory */ CSsize = _DS - _CS; /* when small model */ ptr = (char *)__heapbase + _stklen + _heaplen; DSsize = ((unsigned)ptr >> 4) + 1; StartingSP = DSsize << 4; farheap = FP_SEG(_heapbase); /* get segment of the _heapbase */ keepsize = farheap - _psp; /* print the structure of the small memory model */ printf("Porgram segment prefix == %#06x\n", _psp); printf("Code segment == %#06x\n", _CS); printf("Data segment == %#06x\n", _DS); printf("Stack segment == %#06x\n", _SS); printf("Extra segment == %#06x\n", _ES); printf("Offset of static data area to DS == 0x0000\n"); printf("Offset of near heap base to DS == %#06x\n", __heapbase); printf("Offset of near heap top to DS == %#06x\n", __heaptop); printf("Current stack pointer == %#06x\n", _SP); /* print the initial value of SP calculated by three different methods */ printf("Initial value of SP == %#06x\n", StartingSP); printf(" == %#06x(other method)\n", (farheap - _DS) << 4); /* print the map of the far heap */ topofmem = MK_FP(*(unsigned far *)MK_FP(_psp, 0x0002), 0x0000); printf("Far heap base == %Fp\n", _heapbase); printf("Far heap top == %Fp\n", _heaptop); printf("Top of memory == %Fp\n\n", topofmem); /* print sizes */ printf("CS size == %#06x paragraph\n", CSsize); printf("DS size == %#06x paragraph(including stack)\n", DSsize); printf("Keep size == %#06x paragraph\n", keepsize); printf(" == %#06x(other method)\n", 0x10 + CSsize + DSsize); printf("Free space in near heap == %#06x byte(including stack area)\n", _SP - (unsigned)__heaptop + 1); printf("Free space in far heap == %ld byte\n", (unsigned long)(FP_SEG(_heaptop) - FP_SEG(_heapbase)) << 4); printf(" == %ld byte(other method)\n", (unsigned long)(FP_SEG(topofmem) - FP_SEG(_heapbase)) << 4); /* for a TSR program "keep(0, keepsize);" is required before quit program */ } --------------------------------------------------------------------- 실행 결과 (터보 C 2.0에서 컴파일하여 도스 프롬프트상에서 실행) Porgram segment prefix == 0x16c2 Code segment == 0x16d2 Data segment == 0x1822 Stack segment == 0x1822 Extra segment == 0x1822 Offset of static data area to DS == 0x0000 Offset of near heap base to DS == 0x076e Offset of near heap top to DS == 0x076e Current stack pointer == 0x098a Initial value of SP == 0x09c0 == 0x09c0(other method) Far heap base == 18BE:0000 Far heap top == A000:0000 Top of memory == A000:0000 CS size == 0x0150 paragraph DS size == 0x009c paragraph(including stack) Keep size == 0x01fc paragraph == 0x01fc(other method) Free space in near heap == 0x021d byte(including stack area) Free space in far heap == 554016 byte == 554016 byte(other method) --------------------------------------------------------------------- --------------------------------------------------------------------- 11 다음에는 --------------------------------------------------------------------- 별로 한 얘기도 없는데 벌써 이번 글의 끝맺음을 할 때가 된 것 같다. 한꺼번에 너무 많은 얘기를 하면 지루할 것 같아 이쯤에서 일단락 지었다. 다음 달에는 이번 강좌의 핵심인 C와 어셈블리 루틴의 접속(interface)에 대하여 본격적으로 설명을 해 나가겠다.