>>> 터보 C의 깊은 곳 <<< 제2회 터보 C의 각종 메모리 모델과 그 구조 글/임인건 (서울대 기계공학과4) --------------------------------------------------------------------- 1 본문에 앞서 --------------------------------------------------------------------- 지난 달에는 터보 C가 제공하는 세 종류의 포인터, 즉 근거리/원거리/ 거대 포인터의 특징과 사용시 주의 사항에 대하여 설명했다. 이번에는 그 포인터들을 이해하는 데에 필수적인 사항인 "메모리 모델(memory model)" 의 구조/특징/차이점에 관하여 설명하겠다. 미리 말하지만 이번 글은 상당 히 기술적인 내용 일색이라서 맑은 정신으로 임해야지만 끝까지 성공적으 로 완독해 낼 수 있을 것이다. 결코 가볍게 훑어볼 만한 내용은 아니다. 그리고 한 번 읽고 이해하려고 너무 성급하게 덤비지도 말기 바란다. 최소 한 서너번은 읽어야 감이 잡힐 것으로 본다. --------------------------------------------------------------------- 2 터보 C의 메모리 모델 개요 --------------------------------------------------------------------- 터보 C는 도합 6 종류의 메모리 모델을 제공한다. 초소형(tiny), 소 형, 중형, 중소형, 대형, 거대 모델 등이 그것이다. 이들의 구분은 CS, D S, SS, ES 등 네 개의 세그먼트를 어떻게 관리하느냐에 달려 있다. 프로그 래머는 자신의 상황에 알맞게 이들 중에서 메모리 모델을 선택하여 프로그 램을 작성하게 된다. 이들 모델의 개략적인 설명을 하자면 다음과 같다. 나중에 다시 깔끔 하게 비교/정리해 놓을 테니 지금은 그냥 그려려니 하고 대충 훑어보기만 하기 바란다. 무슨 말인지 언뜻 가슴에 와 닿지 않더라도 말이다. 2.1 소형 데이터 모델 [1] 초소형 모델(tiny model) 말 그대로 가장 작은 메모리 모델이다. 이 모델에서는 모든 세그먼트 레지스터가 동일한 번지에 위치하며 프로그램 실행의 전과정을 통털어 고 정적이다. 즉 "항상 CS == DS == SS == ES"이다. 따라서 이 모델에서는 총 64k바이트(축소 가능)의 메모리 공간만이 코드, 데이터, 스택을 위해 할당 된다. 나머지 640k바이트 공간은 직접적으로 제어할 수 없다. 그 밖에 "모 든 포인터는 근거리 포인터로 내정"되는 특징이 있으며, 유일하게 이 모델 만이 .COM 화일을 생성해 낼 수 있다. 그것은 exe2bin.exe 유틸리티를 사 용하거나 터보 링커에 /t 옵션을 지정함으로써 가능하다. 램상주 프로그램 을 제작할 때에는 이 모델을 쓰는 것이 일반적이다. [2] 소형 모델(small model) 이 모델에서는 DS == SS == ES이지만 CS != DS이다. 즉 코드 세그먼트 와 데이터 및 스택 세그먼트가 분리된다. 따라서 초소형 모델에서와는 달 리 스택 또는 데이터가 코드 영역을 침범할 염려가 (정상적인 경우) 절대 없다. 이 모델에서는 최대 64k바이트의 코드 영역과 총 64k바이트(축소 가 능)의 데이터/스택 영역이 존재하며, 결과적으로 최소 64k(축소 가능), 최 대 128k의 메모리를 직접적으로 사용할 수 있다. "모든 포인터는 근거리 포인터로 내정"되며, 대부분의 응용 프로그램에서 이 모델은 적당한 크기 를 가진다. 실제로 터보 C에서는 별도의 컴파일러 옵션을 지정(변경)하지 않는 한 소형 모델이 내정된다. [3] 중형 모델(medium model) 함수 포인터는 원거리 포인터로 내정된다. 따라서 코드는 64k바이트를 가뿐히 초과할 수 있다. 단, 모듈별 분할 컴파일을 해야만 초과가 가능하 다는 전제가 있기는 하다. 하지만 데이터 포인터는 근거리 포인터로 내정 되므로 데이터 및 스택은 총 64k바이트(축소 가능)의 공간을 차지한다. 이 모델은 데이터를 별로 쓰지 않는 대형 프로그램에 적당하다(실제로는 별로 안 쓰임). 참고로 함수 포인터가 원거리 포인터로 내정된다는 말은 모든 함수 호출이 원거리 호출(far call)로 내정된다는 뜻도 포함한다. 2.2 대형 데이터 모델 [4] 중소형 모델(compact model) 이 모델은 중형 모델의 반대이다. 즉 데이터 포인터로 원거리 포인터 가 내정되고, 함수 포인터는 근거리 포인터로 내정된다. 그리고 함수 호출 은 원거리 호출로 내정된다. 따라서 코드는 최대 64k바이트를 초과할 수 없으며, 데이터 포인터로 1M바이트 공간(힙 포함)을 직접적으로 참조할 수 있다. 하지만 정적 데이터는 최대 64k바이트를 초과할 수 없다. 한편 코 드, 데이터, 스택 세그먼트는 각각 독립적으로 존재하며 겹쳐지지 않는다. 이 모델은 코드는 작은 반면 데이터가 대단히 많은 프로그램에 유용하다 (실제로는 별로 안 쓰임). [5] 대형 모델(large model) 함수 포인터와 데이터 포인터로 원거리 포인터가 내정된다. 그리고 함 수 호출은 원거리 호출로 내정된다. 따라서 코드의 분량은 모듈별 분할 컴 파일을 통해 (이론상) 최대 1M바이트까지 가능하고, 데이터 포인터도 역시 1M바이트 공간(힙 포함)을 직접적으로 참조할 수 있다. 하지만 정적 데이 터는 최대 64k바이트를 초과할 수 없다. 한편 코드, 데이터, 스택 세그먼 트는 각각 독립적으로 존재하며겹쳐지지 않는다. 이 모델은 대단히 큰 프 로그램에 쓰이며, 실제로 실행 화일의 크기가 대략 64k바이트 이상인 대부 분의 C 응용 프로그램은 이 모델이라고 보면 거의 틀림없다. [6] 거대 모델(huge model) 64k바이트 이상의 정적 데이터를 가질 수 있다는 것을 제외하고는 대 형 모델과 똑같다. 64k바이트 이상의 정적 데이터를 가질 수 있도록 하기 위해 함수 호출은 거대 호출(huge call)로 내정된다. 하지만 함수 포인터 와 데이터 포인터는 실행 속도를 고려하여 대형 모델처럼 원거리 포인터로 내정된다는 데 주의해야 한다. 이 모델은, 예컨데 대용량의 자형(font) 데 이터를 실행 화일 자체 내에 포함시키고자 할 경우 등에나 쓰이고 보통의 경우에는 거의 쓰이지 않는다. --------------------------------------------------------------------- 3 각 모델들의 메모리 지도 --------------------------------------------------------------------- 다음의 <그림 1>~<그림 6>은 각 모델들의 메모리 지도(memory map)이 다. 여기서 주의해서 살펴볼 것은 아래와 같다. * CS, DS, SS의 상등 여부 및 고정적인가의 여부 * 각 세그먼트의 놓인 순서 (항상 CS <= DS <= SS의 순서임) * 각 세그먼트 크기의 최대 한계 * 정적 데이터 영역의 구조 (항상 초기화된 데이터 -> 비초기화된 데이터의 순서) * 스택 영역의 구조 * 근거리/원거리 힙의 위치 * 스택 및 힙의 성장 방향, 즉 위(하위 번지)쪽이냐 아래(상위 번지)쪽이냐. 한편, 그림에서 위쪽은 하위 번지이고 아래쪽은 상위 번지이다. 또한 겹으로 된 수평선은 독립된 세그먼트의 경계를 나타냄에 특히 주목하여 보 기 바란다. 그 외의 수평선은 해당세그먼트 내 각 영역의 경계를 나타낼 뿐이다. 이는 각 메모리 모델의 구조를 이해하는 데 상당히 중요한 사항이 므로 가능한 한 생각하는 자세로 그림을 보아 줬으면 싶다. 참고로 정적 데이터(static data)란 모든 종류의 외부변수, 정적변수 및 문자열 상수 등을 총칭하는 말이다. 이 때 원시 코드상에서 그 초기치 를 명시한 정적 데이터는 특별히 "초기화된 데이터(initialized data)"라 부르고 명시적으로 초기화되지 않은 데이터는 "비초기화된 데이터(uniniti alized data)"라고 부른다. 둘 사이의 차이점은 이렇다. 즉 초기화된 데이터의 값은 실행 화일 내 에 포함되는 반면에, 비초기화된 데이터의 값은 실행 화일 내에 포함되지 않으며 프로그램이 실행됨과 동시에 기동 코드(startup code)에 의해 0으 로 초기화된다(단, 거대 모델에서는 비초기화된 데이터 영역이 별도로 존 재하지 않으며 모두 초기화된 데이터로 간주한다). <그림 1> 초소형 모델(tiny model)의 메모리 지도 --------------------------------------------------------------------- CS, DS, SS ---> +-------------------+-+ (ES == DS)(1)| | | | 코드 | | | | | +-------------------+ |-+ | 초기화된 데이터 | | | |-------------------| | |(2) | 비초기화된 데이터 | | | +-------------------+ |-+ | 근거리 힙(4) | | |-------------------| | 정확히 64k바이트(3) | | | | 여유 공간 | | | | | |-------------------| | <--- SP(가변) | 스택 | | +-------------------+-+ <--- SP 초기치 (1) 원거리 포인터를 전혀 쓰지 않을 경우에만. (2) 두 영역을 합해 "정적 데이터 영역"이라 부른다. (3) 메모리가 모자라면 그에 맞게 자동적으로 축소되며 외부변수 _stklen, _heaplen의 초기치를 변경하여 의도적으로 64k바이트 이하로 축소시킬 수 있다. (램상주 프로그램 등에서) (4) malloc, calloc/free 함수를 써서 할당/해제한다. * 초소형 메모리에서도 원거리 힙이 있을 수 있지만 실제 사정상 거의 쓰이지 않으므로 그림에 나타내지 않았다. --------------------------------------------------------------------- <그림 2> 소형 모델(small model)의 메모리 지도 --------------------------------------------------------------------- CS ---> +-------------------+-+ | | | | 코드 | | 최대 64k바이트까지 | | | +-------------------+-+-+ (ES == DS) | 초기화된 데이터 | | | (1) |-------------------| | |(2) | 비초기화된 데이터 | | | +-------------------+ |-+ | 근거리 힙(4) | | | near heap | | |-------------------| | 정확히 64k바이트(3) | | | | 여유 공간 | | | | | |-------------------| | <--- SP(가변) | 스택 | | +-------------------+-+ <--- SP 초기치 | 원거리 힙(5) | | | far heap | | |-------------------| | | | | | 여유 공간 | | | free space | | 남는 메모리 끝까지 +-------------------+-+ (1)(2)(3)(4) 초소형 모델 참고 (5) farmalloc/farfree 함수 또는 allocmem/freemem 함수를 써서 할당/해제한다. --------------------------------------------------------------------- <그림 3> 중형 모델(medium model)의 메모리 지도 --------------------------------------------------------------------- +- 함수 호출(원거리 호출)시에만 | 그 함수가 존재하는 모듈의 | 세그먼트 선두를 가리키도록 변경되며 | 그 외에는 고정적이다. | CS -+-> +-------------------+-+ | | 모듈1 | | +-> +-------------------+-+ | | 모듈2 | | +-> +-------------------+-+ 각 모듈 최대 64k바이트까지 | | ......| | +-> +-------------------+-+ | 모듈n | | DS, SS ---> +-------------------+-+-+ (ES == DS) | 초기화된 데이터 | | | (1) |-------------------| | |(2) | 비초기화된 데이터 | | | +-------------------+ |-+ | 근거리 힙(4) | | |-------------------| | 정확히 64k바이트(3) | | | | 여유 공간 | | | | | |-------------------| | <--- SP(가변) | 스택 | | +-------------------+-+ <--- SP 초기치 | 원거리 힙(5) | | |-------------------| | | | | | 여유 공간 | | 남는 메모리 끝까지 +-------------------+-+ (1)(2)(3)(4)(5) 초소형 모델 참고 * 지도에서 복선은 독립된 세그먼트의 경계를 나타내며 단선, 또는 점선은 동일한 세그먼트 내에서 각 영역의 경계를 나타낸다. (다른 그림에서도 마찬가지) --------------------------------------------------------------------- <그림 4> 중소형 모델(compact model)의 메모리 지도 --------------------------------------------------------------------- CS ---> +-------------------+-+ | | | | 코드 | | 최대 64k바이트까지 | | | DS ---> +-------------------+-+ (ES == ??) | 초기화된 데이터 | | (1) |-------------------| | 최대 64k바이트까지(2) | 비초기화된 데이터 | | SS ---> +-------------------+-+ | 여유 공간 | | 4k바이트(3) |-------------------| | <--- SP(가변) | 스택 | | +-------------------+-+ <--- SP 초기치 | (원거리) 힙(4) | | |-------------------| | | | | | 여유 공간 | | 남는 메모리 끝까지 +-------------------+-+ (1) ES는 원거리 포인터를 위해 쓰이며 그때그때 값이 변한다. (2) 두 영역을 합해 "정적 데이터 영역"이라 부른다. (3) 외부변수 _stklen을 재정의하여 변경할 수 있다. (4) 근거리 힙이 따로 존재하지 않으므로 그냥 힙이라고 부른다. malloc,calloc/free 함수에 의해 해제/설정한다. --------------------------------------------------------------------- <그림 5> 대형 모델(large model)의 메모리 지도 --------------------------------------------------------------------- +- 함수 호출(원거리 호출)시에만 | 그 함수가 존재하는 모듈의 | 세그먼트 선두를 가리키도록 변경되며 | 그 외에는 고정적이다. | CS -+-> +-------------------+-+ | | 모듈1 | | +-> +-------------------+-+ | | 모듈2 | | +-> +-------------------+-+ 각 모듈 최대 64k바이트까지 | | ...... | | +-> +-------------------+-+ | 모듈n | | DS ---> +-------------------+-+ (ES == ??) | 초기화된 데이터 | | (1) |-------------------| | 최대 64k바이트까지(2) | 비초기화된 데이터 | | SS ---> +-------------------+-+ | | | 4k바이트(3) |-------------------| | <--- SP(가변) | 스택 | | +-------------------+-+ <--- SP 초기치 | (원거리) 힙(4) | | | heap | | |-------------------| | | | | | 여유 공간 || | free space | | 남는 메모리 끝까지 +-------------------+-+ (1)(2)(3)(4) 중소형 모델 참고 --------------------------------------------------------------------- <그림 6> 거대 모델(huge model)의 메모리 지도 --------------------------------------------------------------------- +- 대형 모델 참조 | CS -+-> +-------------------+-+ | | 모듈1 | | +-> +-------------------+ | | | 모듈2 | | +-> +-------------------+ | 각 모듈의 코드 | | ...... | | 최대 64k바이트까지 +-> +-------------------+ | | 모듈n | | DS -+-> +-------------------+-+ | | 모듈1의 데이터 | | (ES == ??) +-> +-------------------+ | (1) | | 모듈2의 데이터 | | +-> +-------------------+ | 각 모듈의 데이터 | | ...... | | 최대 64k바이트까지 +-> +-------------------+ | (2) | 모듈n의 데이터 | | SS ---> +-------------------+-+ | | | 4k바이트(3) |-------------------| | <--- SP(가변) | 스택 | | +-------------------+-+ <--- SP 초기치 | (원거리) 힙(4) | | |-------------------| | | | | | 여유 공간 | | 남는 메모리 끝까지 +-------------------+-+ (1)(3)(4) 중소형 모델 참고 (2) 초기화된 데이터만을 의미한다. 비초기화된 데이터 영역은 별도로 존재하지 않는다. --------------------------------------------------------------------- --------------------------------------------------------------------- 4 메모리 모델의 분류 --------------------------------------------------------------------- <표 1> 메모리 모델의 분류 -------------+--------------------------------------------------- | 코드 크기(code size) 데이터 크기 +---------------------+----------------------------- (data size) | 64k 이하 | 1M 이하 -------------+---------------------+----------------------------- | 초소형 | 64k 이하 | (코드, 데이터 중첩) | | 소형 | 중형 | (코드, 데이터분리) | -------------+---------------------+----------------------------- | 중소형 | 대형 1M 이하 | | (정적 데이터 64k 이하) | | 거대 | | (정적 데이터 64k 초과 가능) -------------+---------------------+----------------------------- <표 1>에 각종 메모리 모델을 그 대표적인 특징에 따라 분류해 놓았 다. 이와 같이 코드나 데이터 크기의 한계에 따라서 메모리 모델을 분류하 는 것이 가장 일반적이다. 그런데 살다 보면 코드나 데이터 크기에 따라 이들을 총칭하는 용어가 자주 필요해지는데, 이에 따라 그러한 용어들을 아래와 같이 정의해서 쓰고 있다. * 데이터 크기에 따른 분류 - 소형 데이터 모델: 초소형, 소형, 중형 - 대형 데이터 모델: 중소형, 대형, 거대 * 코드 크기에 따른 분류 - 소형 코드 모델: 초소형, 소형, 중소형 - 대형 코드 모델: 중형, 대형, 거대 --------------------------------------------------------------------- 5 각 메모리 모델의 특징 --------------------------------------------------------------------- 앞 절의 용어를 써서 각종 메모리 모델의 특징을 사안별로 비교/설명 하면 다음과 같다. <그림 1>~<그림 6>을 참고하면서 세심하게 따져 보기 바란다. --------------------------------------------------------------------- * 내정된 포인터 - 소형 데이터 모델: 근거리 포인터(near pointer) - 대형 데이터 모델: 원거리 포인터(far pointer) (거대 모델에서도 원거리 포인터가 내정됨에 주의!) * 내정된 포인터의 바이트 크기 - 소형 데이터 모델: 2바이트 - 대형 데이터 모델: 4바이트 * 내정된 함수 호출 방식 - 소형 코드 모델: 근거리 호출(near call) - 중형/대형 모델: 원거리 호출(far call) - 거대 모델: 거대 호출(huge call) (거대 호출은 함수 호출 직전에 그 함수가 존재하는 모듈에 딸린 독립적인 데이터 세그먼트의 선두를 DS가 가리키도록 그 값을 변경함을 뜻한다. <그림 6> 참고) --------------------------------------------------------------------- * 데이터(힙 포함)의 총 크기 - 소형 데이터 모델: 최대 64k바이트까지(근거리 힙 포함) - 대형 데이터 모델: (이론상) 최대 1M바이트까지(힙 포함) * 정적 데이터 영역(외부변수/정적변수/문자열 상수)의 크기 - 소형 데이터 모델: 최대 64k바이트까지 - 중형/대형 모델: 최대 64k바이트까지(요주의!!!) - 거대 모델: (이론상) 최대 1M바이트까지 (단, 각 모듈의 정적 데이터 크기는 64k바이트를 초과할 수 없다!!) * 코드의 총 크기 - 소형 코드 모델: 최대 64k바이트까지 -대형 코드 모델: (이론상) 최대 1M바이트까지 (단, 각 모듈의 코드 크기는 64k바이트를 초과할 수 없다!!) --------------------------------------------------------------------- * 각 세그먼트의 배치 - 초소형 모델: CS == DS == SS == ES - 소형 모델: CS < DS == SS == ES - 중형 모델: CS < DS == SS == ES - 중소형 모델: CS < DS < SS ES == ?? - 대형 모델: CS < DS < SS ES == ?? - 거대 모델: CS < DS < SS ES == ?? * 코드/데이터 세그먼트의 중첩(overlap) 여부 - 초소형 모델만 겹치고(CS == DS) 나머지는 모두 독립적으로 분리됨(CS < DS) * 데이터/스택 세그먼트의 중첩 여부 - 소형 데이터 모델: DS == SS - 대형 데이터 모델: DS < SS, 즉 독립적으로 분리됨 * CS 값의 가변 여부 - 소형 코드 모델: CS == 코드 세그먼트의 선두 == 고정 불변 - 대형 코드 모델: CS는 서로 다른 모듈에 있는 함수를 (원거리) 호출할 때마다 해당 모듈의 세그먼트 선두를 가리키도록 변경된다. 그 외에는 고정적. * DS 값의 가변 여부 - 거대 모델: 서로 다른 모듈에 있는 함수를 (원거리) 호출할 때마다 해당 모듈에 속하는 정적 데이터 영역의 세그먼트 선두를 가리키도록 변경된다(-> 거대 호출). 그 외에는 고정적. - 그 외의 모델: DS == 정적 데이터 영역의 세그먼트 선두 == 고정 불변 * ES 값의 가변 여부 - 소형 데이터 모델: ES == DS == 고정 불변 (단, 원거리 포인터를 사용하지 않았을 경우) - 대형 데이터 모델: ES == ?? == 가변 (원거리 포인터를 위해 쓰인다) --------------------------------------------------------------------- * 근거리 힙(near heap)의 크기 - 초소형 모델: (데이터 세그먼트의 크기) - (코드 크기) - (정적 데이터 영역) - (사용된 스택 크기) - 소형/중형 모델: (데이터 세그먼트의 크기) - (정적 데이터 영역) - (사용된 스택 크기) (데이터 세그먼트의 크기는 외부변수 _heaplen이 0(내정치)일 경우 정확히 64k(65536)바이트이고, 만약 외부변수 _stklen과 _heaplen의 초기치를 프로그램에서 지정한 경우 64k바이트 이하로 줄일 수 있다. 더불어 메모리가 부족할 때에도 데이터 세그먼트의 크기가 그에 알맞게 줄어든다. Turbo C Reference Guide 매뉴얼 참조) - 대형 데이터 모델: 근거리 힙이 존재하지 않는다. --------------------------------------------------------------------- * 특별히 컴파일러 옵션을 변경하지 않았을 때 내정되는 메모리 모델 - 소형 모델이 내정된다. 따라서 일반적인 경우 근거리 포인터/근거리 호출이 내정되며 코드와 데이터 세그먼트는 분리된다. --------------------------------------------------------------------- #49 임인건 (turbo28 ) [강좌] C깊은곳2-2: 메모리 모델과 그 구조 05/06 00:09 288 line --------------------------------------------------------------------- 6 번지지정 수식자(addressing modifier) --------------------------------------------------------------------- 터보 C는 ANSI C 사양에 기초하지 않은 7개의 수식자(modifier)를 추 가로 제공한다. near, far, huge, _cs, _ds, _es, _ss 여기서 뒤의 4개는 다른 언어(특히 파스칼)과의 링크에서나 필요한 것 이므로 설명을 생략하고, 대신 앞의 3개에 관해서 중점적으로 설명하겠다. 터보 C에서는 포인터나 함수 호출의 내정된 방식을 프로그래머가 임의로 변경할 수 있다. 예컨데 소형 데이터 모델에서는 근거리 포인터가 내정되 지만 프로그래머는 원거리 포인터를 쓰기 위해 포인터의 데이터형을 변경 할 수 있다. 이처럼 내정된 포인터형이나 함수 호출 방식을 변경시키고자 할 때 (주로) near, far, huge 수식자가 쓰인다. 여기서 near, far 등등을 수식자라 부르는 이유는 포인터형임을 나타내는 구두점 *를 문법적으로 수 식하는 역할을 하기 때문이다. --------------------------------------------------------------------- 7 근거리/원거리/거대 포인터의 정의 --------------------------------------------------------------------- 예를 들어서, (char *)형 포인터(문자열 포인터) str이 소형 데이터 모델에서 아래와 같이 정의되어 있다고 치자. 그러면 str은 근거리 포인터 로 내정된다. char *str; 이 때 str을 원거리 포인터로 바꾸려면 "*"를 "far *"로 치환하면 된 다. 즉 수식자 far를 구두점 * 앞에 놓으면 된다. char far *str; 만약 대형 데이터 모델에서 str을 근거리 포인터로 정의하고 싶다면, char near *str; 이라고 기술하면 된다. 거대 포인터를 원한다면 near 대신에 huge를 쓰는 것으로 족하다. 일반적으로 어떤 데이터형 T가 있고 T형 데이터를 가리키는 포인터 pt r이 아래와 같이 정의되어 있을 때(ptr은 꼭 변수명일 필요가 없다), T *ptr; ptr의 내정된 포인터형을 변경시키고자 하면 "*ptr"을 "near *ptr", "far *ptr", "huge *ptr"로 그대로 치환하기만 하면 된다. 이 때 (ptr이 변수명 이 아닐 때) 필요하면 아래와 같이 ptr에 괄호를 두름으로써 *나 [ ], ( ) 등의 구두점의 우선 순위에 변동이 생기기 않도록 해야 한다. 그 외의 다 른 부분은 건드리면 안 된다. T near *ptr; T far *ptr; T huge *ptr; T near *(ptr); T far *(ptr); T huge *(ptr); 예를 들어 소형 모델에서 이차원 배열 포인터 py가 아래와 같이 정의 되어 있을 때, int ss[3][10]; int (*py)[10]; py = ss; py를 원거리 포인터로 데이터형을 변경하려면 아래와 같이 한다. int (far *py)[10]; 다음은 포인터의 포인터(포인터를 가리키는 포인터)를 정의한 예이다. char **pps; ppx를 원거리 포인터를 가리키는 원거리 포인터로 바꾸면 아래와 같 다. char far *(far *pps); 또는 괄호를 제거하여 char far *far *pps; 만약 위의 정의를 "char far **ppx"라고 하면 소형 데이터 모델에서는 "char far *near *ptr"이 되어 결과적으로 "원거리 포인터를 가리키는 근 거리 포인터"가 되므로 주의하기 바란다. 다음은 각종 원거리/거대 포인터를 정의한 예이다. 포인터 변수의 원 래 데이터형은 "far *"이나 "huge *"를 "*"로 재치환하면 쉽게 파악할 수 있을 것이다. int far *px; ← 일차원 배열 포인터(원거리) char huge *px; ← 문자열 배열 포인터(거대) int (far *fp)(double x); ← 함수 포인터(원거리) double (far *py)[100]; ← 이차원 배열 포인터(원거리) void far *ptr; ← void형 원거리 포인터 --------------------------------------------------------------------- 8 끝으로 --------------------------------------------------------------------- 이번 달의 글은 독자들에게 지루함 내지 당혹한 감이 없지 않았을 줄 로 안다. 아직까지도 얘기가 실질적인 부분에 접어들지 못했기 때문에, 예 제도 없이 설명을 강행해 나갈 수밖에 없었다. 게다가 글이 워낙 기술적이 라서 한번에 많은 분량의 글을 게재하기도 뭐한 탓도 있었다. 다음 달에는 근거리/원거리/거대 호출 방식의 특징 및 차이점에 대해 알아보고, 더불어 소형 모델과 대형 모델에 국한하여 스택 영역을 64k바이 트 이하로 축소시키는 방법과 세그먼트 각 부분의 위치(가령 데이터 세그 먼트의 크기, 힙의 선두 번지 등등)를 알아내는 비법을 소개하겠다. 물론 다음 달부터는 조금은 실질적인 설명과 예제가 이어질 것이므로 지루하지 않게 눈으로 확인하면서 터보 C의 깊은 곳을 파헤쳐 나갈 수 있을 것이다. --------------------------------------------------------------------- 9 덤으로 --------------------------------------------------------------------- 아무런 예제도 없이 그냥 글을 마치려니까 아무래도 떨떠름해서 덤으 로 최고급 난이도의 예제를 하나 소개한다. 다음의 예제 memmodel.c는 소 형 모델에서의 실제적인 메모리 지도를 보여 준다. 터보 C의 깊은 곳을 눈 으로 직접 확인할 수 있는 좋은 기회가 아닐까 생각한다. 메모리 지도를 얻기 위해서는 메모리 각 영역의 시작과 끝 번지(또는 세그먼트 경계)를 알아야 하는데 이 예제에서는 시작과 끝 번지를 구하기 위하여 한 가지 이상의 방법을 사용하고 있다. 실행 결과를 보면 여러 가 지 방법에 의해 구한 번지값들이 서로 완전하게 잘 일치하고 있음을 볼 수 있을 것이다. 이 예제는 반드시 터보 C 2.0에서 소형 모델(내정치 그대로)로 컴파일 /링크해야 한다. 다음의 실행 결과는 터보 C 2.0 통합 개발 환경하에서 컴 파일러 옵션을 전혀 변경하지 않은 채(디버깅 모드 상태)로 그 결과를 출 력한 것이다. 참고로 이 예제는 데이터 세그먼트의 크기를 내정치인 64k바이트보다 축소시키기 위하여, 스택의 크기를 설정하는 외부변수 _stklen의 초기치를 0x0250으로, 근거리 힙의 크기를 설정하는 외부변수 _heaplen의 초기치를 0x0001로 잡아, 기동 코드(startup code)로 하여금 데이터 세그먼트의 크 기를 대폭 축소시키도록 했다. 자세한 사항은 Turbo C 2.0 Reference Guid e 매뉴얼 28쪽, 30쪽을 참고하기 바란다. 지면 사정상, 시간 관계상 이 예제의 분석은 다음 달로 미룰 수밖에 없을 것 같다. 그러나 서투른 영어지만 주석을 충분히 달아 두었으므로 의 욕만 있다면 예제를 분석하는 게 어렵지만도 않을 것이다. 다만 go_up_sta ck 함수는 스택을 꺼꾸로 거슬러 올라가서 SP의 초기치(스택의 최상위 번 지값)를 구해 주는 함수로서, 이 함수는 터보 C 패키지에 딸려 있는 기동 코드 c0.asm의 어셈블리 원시 화일을 분석하지 않고는 전혀 이해할 수가 없기 때문에, 지금은 그냥 그려려니 하기 바란다. 그 외의 나머지 부분은 독자 스스로 분석해 낼 수 있으리라 믿는다. 발등이 찍힐지는 모르겠지 만... <예제 MEMMODEL.C> 소형 모델에서의 실제적인 메모리 지도 --------------------------------------------------------------------- /* 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 *go_up_stack(unsigned BP, int argc, char *argv[]) { int i; BP += 2; /* for "push bp" in the main function */ BP += 2; /* for return address when quit the main function (small code model) */ BP += 6; /* for argc, argv, envp(6 byte) */ BP += argc * 2; /* for argv[0], ..., argv[argc - 1] */ BP += 2; /* for argv[argc](== NULL) */ for (i = 0; i < argc; i++) /* for strings pointed by argv[i]s */ BP += strlen(argv[i]) + 1; if ((BP & 0x0001) != 0) BP++; /* for word alignment(dummy 0x00 byte)*/ BP += 2; /* for dummy return address(== 0x00fb) */ return (void *)BP; /* BP is the initial value of SP */ /* sometimes BP == StartingSP - 2 because of the additional dummy return address(2 byte) */ } 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); printf(" == %#06x(other method)\n", go_up_stack(_BP, argc, argv)); /* 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 통합 개발 환경하에서 소형 모델로 컴파일/링크/실행. PSP의 세그먼트값 등이나 원거리 힙의 크기 등은 시스템 상황에 따라 가변적이다. 그러나 상대적인 값은 시스템에 상관없이 일정하리라 본다.) Porgram segment prefix == 0x847e Code segment == 0x848e Data segment == 0x85e6 Stack segment == 0x85e6 Extra segment == 0x85e6 Offset of static data area to DS == 0x0000 Offset of near heap base to DS == 0x079a Offset of near heap top to DS == 0x079a Current stack pointer == 0x09ba Initial value of SP == 0x09f0 == 0x09f0(other method) == 0x09f0(other method) Far heap base == 8685:0000 Far heap top == A000:0000 Top of memory == A000:0000 CS size == 0x0158 paragraph DS size == 0x009f paragraph(including stack) Keep size == 0x0207 paragraph == 0x0207(other method) Free space in near heap == 0x0221 byte(including stack area) Free space in far heap == 104368 byte == 104368 byte(other method) ---------------------------------------------------------------------