A!die Software Studio Welcome to A!Die Software Studio

TURBOC六种编译模式概述

by other
2011-05-29 09:49:58
六种编译模式概述
Turbo C 提供了六种编译模式。编译模式有时也称为寻址模式或
内存模式,因为它处理的就是如何在内存中为程序,数据,堆栈分配
空间并存取它们,这六种模式是:微模式tiny,小模式small, 紧凑
模式compact,中模式medium,大模式large,巨模式huge。它们之间
的关系如下表所示。 │ 小程序 │ 大程序
━━━━┿━━━━━━┿━━━━━━━━
小数据 │ 微,小 │ 中
大数据 │ 紧凑 │ 大,巨 所谓小程序就是只有一个程序段,当然不超过64K 字节,缺省的
码(函数)指针是near。所谓大程序就是有多个程序段,每个程序段不
超过64K字节,但总程序量可超过64K字节,缺省的码指针是 far。所
谓小数据就是只有一个数据段,缺省的数据指针是near。所谓大数据
就是有多个数据段,缺省的数据指针是 far。下面还会逐个谈到它们
之间的差别,并通过同一程序在六种不同模式下的输出结果,来进一
步加深对这六种模式的理解。但先要强调一点:无论使用哪一种编译
模式,单个的Turbo C源文件不可能生成大于64K字节的代码,也不能
生成大于64K字节的静态(包括全局)数据。例如下面这个程序: int a[15000],b[20000];
void main(){}
在任何模式下都不能编译。这是因为,两个数组所要求的总存储量达
70K字节。编译时会报出"Too much global data defined in file"
的出错信息。为了处理大于64K 字节的代码或静态数据,必须分成几
个源文件。以上面这个程序为例,可以分成文件A1.C和A2.C,分别用
巨模式对这两个源文件进行编译,最后连接成一个可执行文件。 al.c a2.c a.prj
int a[15000]; int b[20000]; a1
void main() a2
a1.obj(30k) a2.obj(40k) a.exe(71k)
六种编译模式的差别是:它们对来自不同源文件的码和数据段的
处理不同,对动态分配的堆空间的处理不一样,对指针使用也不一样。
此外,它们的所形成的 .obj 文件中传给连接程序的信息也不一样,
以便连接程序相应地安排码段和数据段,把相应的说明放在 .exe 文
件的头中并借此通知DOS:当执行这个程序时如何装入码段和数据段,
如何设置各个段寄存器。
用于演示六种编译模的程序是由两个源文件X.C和Y.C组成,如下
所示:
/* X.C */
#include<general.h>
void a()
{
static int b;
int c;
printf("In function A \n");
printf(" CS : %X \n",_CS);
printf(" DS : %X \n",_DS);
printf(" SS : %X \n",_SS);
printf(" Static B : %p \n",&b);
pritnf(" Automatic C : %p \n",&c);
}
/* Y.C */
#include<general.h>
int d;
void main(){
int e;
a();
printf("In function main \n");
printf(" CS : %X \n",_CS);
pritnf(" DS : %X \n",_DS);
pritnf(" SS : %X \n",_SS);
pritnf(" Global D : %p \n",&d);
pritnf(" Automatic E : %p \n",&e);
printf(" Heap address : %p \n",malloc(2));
#if defined(__TINY__)||defined(__SMALL__)||defined(__COMPACT__)
pritnf("Function A : %Np \n",a);
pritnf("Function main : %Np \n",main);
}
#else
printf("Function A : %Fp \n",a);
printf("Function main : %Fp \n",main);
}
#endif 第一个源文件包含函数a和一个静态(局部)变量b,第二个源文件
包含主函数main和一个全局变量d 。两个源文件中各含有一个自动变
量c和e。第二个源文件的主函数main调用了第一个源文件中的函数a,
还调用了Turbo C 的库函数malloc去分配一块堆空间。两个源文件是
分别编译的,然后再通过连接程序连接起来。
通过以六种不同模式编译这两个源文件,可以看到它们是如何为
码、数据和堆栈段分配空间,可以看到静态变量、自动变量和堆变量
分别存放在什么位置,函数放在什么地方。正如下面将要看到的那样,
在某些模式下,数据指针是near而函数指针是 far;在另一些模式下 
情况又正好相反。
对于数据指针,不管是far还是near,pritnf函数中的格式说明 %p都
能把指针正确地打印出来。对于函数,指针%p就没有这个功能。所以,
在main函数中必须加条件编译控制行#if、#else和#endif。微模式
在微模式下,整修程序只有一段,这个段内包含码、静态和全局
数据、堆栈和堆。因为只有一个段,在执行时DOS将把寄存器CS、DS、
SS设置为相等,全都指向这个段。在这个段内,码是首先装入的,地
址最低,接着是静态变和全局变量,然后是堆,最后地堆栈。堆和堆
栈都是动态的,堆从低地址往高地址增长,堆栈从高地址往低地址增
长。若两者相碰,则表示内存空间已耗尽。在微模式下,所有指针都
是near,且都是相对于寄存器CS、DS和SS的。对于用微模式编译并连
接生成的 .exe文件,DOS的exe2bin实用程序转换为 .COM文件。
从下表演示程序的输出结果可以看出,函数a 比函数main的地址
低,变量b比变量d的地址低。这是因为,在连接时是x.obj在前,
y.obj在后。
微模式 小模式 紧凑模式 中模式 大模式 巨模式
In function A
CS : 74C8 74B1 74B1 74F9 74FD 74FE
DS : 74C8 75CC 7629 75EC 764A 7674
SS : 74C8 75CC 767A 75EC 76A0 76BB
Static B : 1704 048C 7629:04C8 049A 764A:04D6 7674:0002
Automatic C : FFD0 FFD0 767A:0FD6 FFCC 76A0:0FD4 76BB:0FD0
In function main
CS : 74C8 74B1 74B1 74FE 7502 7503
DS : 74C8 75CC 7629 75EC 764A 767B
SS : 74C8 75CC 767A 75EC 76A0 76BB
Global D : 1706 048E 7629:04CA 049C 764A:04D8 767B:0004
Automatic E : FFD6 FFD6 767A:0FDE FFD4 76A0:0FDC 76BB:0FDA
Heap Address: 1792 051A 777C:000C 0568 77A2:000C 77BD:000C
Function A : 0283 01A5 0167 74F9:000E 74FD:000D 74FE:0003
Function main: 02C1 01E3 01AE 74FE:0004 7502:000C 7503:0009小模式
小模式是常用的模式,本书中大部分例子都是用小模式编译的。
虽然小模式与微模式一样,都是小数据、小程序模式,但它与微模式
有两点重要的差别。第一,码和数据/堆栈/堆段是分开的,所以CS不
等于DS和 SS。第二,除了和数据/堆栈共用一个段的堆外,还有一个
远堆,以far指针进行存取。从数据/堆栈段的末尾直到常规内存的末
尾都是属于远堆。
因为码、静态数据和(近)堆仍然在同一个段内,所以小模式下缺
省的数据指针和函数指针都是near。结果,在小模式下不能直接通过
该模式下的Turbo C 函数来处理远堆中的变量。然而,只要程序提供
自己的操作函数,就可以存取整个远堆中的任一单元,即可以使用整
个常规内存。中模式
在数据/堆栈/堆的分配方面,中模式与小模式是一样的,差别在
于码段的分配。在中模式下,来自不同源文件的码模式放在不同的码
段内。严格地讲,同一源文件内的各函数也是放在不同码段内。各码 
段的总空间数只受微机上可用内存的限制。因为有多个码段,所以
Turbo C必须用far函数指针。在演示程序输出的结果中函数a 的地址
为74F9:000E,函数main的地址为74FE:0004。函数a 的地址较低,是
因为在连接时包含函数a的x.obj在前。在中模式下,堆仍然有近堆和
远堆之分。紧凑模式
紧凑模式在概念上是最简单的,码、静态数据、堆栈、堆各有其
自己的段。堆只有远堆,没有近堆。像小模式和中模式中的远堆一样,
堆是用far指针来存取的。可以用Turbo C的库函数来处理堆变量。所
有数据指针都是far,函数指针都是near。 从演示程序的输出中可以 
看出,CS、DS、SS三个寄存器的值彼此不等。值得注意的是,静态数
据的总量仍不可超过64K字节。大模式
在静态数据/堆栈/堆的分配方面,大模式等同于紧凑模式。在码
的分配方面,大模式等同于中模式。无论是数据指针还是函数指针,
一律都是远指针。与紧凑模式一样,静态数据的总量不可超过64K 字
节。巨模式
巨模式取消了静态数据总量不可超过64K 字节的限制。来自不同
源文件的码放在不同的段内,来自不同源文件的静态数据也是放在不
同的段内,只有堆栈是合在一起的。以前举的例子就是利用了这一特
点。从演示程序的输出中也可以看,当从函数main内调用函数a 时,
不但CS改变了,DS也改变了。当然,两个函数共用了同一个堆栈,否
则就无法正确返回。应该注意的是,不要把巨模式和巨指针混为一谈,
在巨模式下缺省的指针仍是far而不是huge。堆栈的组织
Turbo C 堆栈是用来存储其生命期与函数生命期相同的数据,这
样的数据包括函数参数和函数体内定义的自动变量。为了表明函数堆
栈内部各数据的存放关系,设有这样一个函数定义: long f(char a,int b)
{
int c;
char d;
....
每当调用函数f 时,调用进行首先按相反顺序,即按从右到左的
顺序把调用参数压入堆栈。本例就是先压入 b,再压入a。尽管参数a
是字符型,但仍压入16位,因为80X86的机器没有8位的压栈指令。在
压入参数之后,根据调用指令是near还是far,再压入 2个或4个字节
的返回地址。
进入被调用函数 f之后,它首先把寄存器BP的当前值压入堆栈,
并把SP寄存器的值拷贝到BP寄存器。接着再次执照相反的顺序在堆栈
内建立起函数体内的各个自动变量,本例里就是先d后c。直到此时,
堆栈的内容将会如下所示:
....
b
a
返回地址
保留的BP
d
c 这里之所以要对BP和SP 作如此处理,目的有3个。第一,为了利
用BP作地址寄存器,通过[BP±n] 这样的寻址方式到堆栈中存取调用
者传过来的参数和被调用函数自己的自动变量。因为在80X86中规定,
当用BP作地址寄存器时,缺省的段地址是SS而不是DS。第二,腾出DS
和其它地址寄存器,仍用来存取缺省的数据段内的数据。第三,腾出
SP以便在函数体内再调用其它函数。
当函数 f完成了它的工作以后,它就把返回值放到相应的位置。
如果返回值是char型,则在返回前先强制转换为 int型。凡是返回值
占两个字节的都通过寄存器AX返回,凡是返回值占 4个字节的都是通
过寄存器对DX:AX返回。超过4个字节的struct返回值,则被放在一个
静态变量内,返回的是指向这个变量的指针。dboule返回值是放在数
值协处理器的top_of_stack寄存器或协处理器软件模拟包内与这个寄
存器等效的地方。接着函数f 把BP拷贝到SP,从堆栈中弹出入口时保
留的BP值到BP寄存器。最后执行一条near 或far返回指令,返回到调
用者。返回以后,调用函数必须把调用调用时压入堆栈的参数从堆栈
中清除。
上面这一套函数调用规则就叫做 C调用规则。从这个过程中可以
看出,调用函数和被调用函数在参数数目上可以不一致。如果调用函
数压了过多的参数,被调用函数不存取这些多余参数是没有什么影响 
的,调用函数在重新获得控制权后,会正确地把这些参数清除掉。如
果调用函数压入了过少的参数,被调用函数就可能把一些并非参数的
内容取来人微言轻参数而产生意想不到的结果。为了克服这个困难,
如果参数数目是不定的,那么第一个参数最好是说明随后的参数的个
数。
另一套不同的函数调用规则叫做PASCAL规则,它与 C调用规则有
两点重要的差别。第一,压入参数的顺序是从左到右。第二,被调用
函数的工作完成以后,从堆栈中弹出参数是由被调用函数而不是由调
用函数去完成。PASCAL调用规则要求调用函数和被调用函数参数上数 
完全一致。顺便说一句,Turbo PASCAL语言使用的不是PASCAL调用规
则,而是一种更为精心设计的堆栈格式,使得从被嵌套的函数内可以
存取函数的自动变量。堆的组织
前面已经说过,在小模式和中模式下,堆有近堆和远堆之分,处
理办法也不一样。近堆和堆栈共享一个段,它们相向增长,如果相遇,
则说明缺省数据段已耗尽。远堆使用了缺省数据段之上直至常规内存
末尾的整个空间。为了管理这两个堆,Turbo C 提供了两组相应的函
数:
coreleft farcoreleft
realloc farrealloc
malloc farmalloc
free farfree
calloc farcalloc 左边的近堆函数用近指针寻址各个堆变量,所用的参数也都16位
的unsigned型。右边的远堆函数用远指针寻址各个堆变量,所用的参
数也都是unsigned long型。
在微模式下没有远堆,在紧凑模式、大模式和巨模式下只有一个
不改堆,其组织形式如同远堆。但在这三种模式下,既可以使用近堆
函数也可以使用远堆函数存取堆中变量。这是因为,不管使用哪一种
堆函数,这三种模式决定了所有数据指针是far。如果使用近堆函数,
则表示所需容量的参数size还必须是unsigned型的16位数。如果必须
处理大于64K字节的内存块,还必须使用远堆函数。
分配和释放是随机进行的,没有一定的次序,结果就造成了各个
堆变量在堆中是不连续的。Turbo C 用一个链表来处理这些堆变量。
在每一个堆变一的前面都有一个头,头中包含两个信息:此变量的长
度和指向下一个堆变量的指针。对于小数据模式,每个头占4个字节,
对于大数据模式,每个头占8个字节。
为了说明分配、释放、再分配在堆中是如何进行的,请看下面这
个演示程序htap.dem的输出结果。#include<stdio.h>#define report printf("coreleft=%u\n",coreleft());void main()
{
void *p,*q,*r;
printf(" ");report;p=malloc(1);
printf("p=malloc(1) =%p;",p);report;q=malloc(2);
printf("q=malloc(2) =%p;",q);report;q=realloc(p,3);
printf("p=realloc(P,3)=%p;",p);report;r=malloc(1);
printf("r=malloc(1) =%p;",r);report;free(q);
printf(" free(q) ");report;free(p);
printf(" free(p) ");report;
}
这个程序产生的输出如下:
coreleft = 63952
p=malloc(1) = 0500; coreleft = 63946
q=malloc(2) = 0506; coreleft = 63940
p=realloc(P,3) = 050c; coreleft = 63932
r=malloc(1) = 0500; coreleft = 63932
free(q) coreleft = 63932
free(p) coreleft = 63946 这个演示程序是用小模式编译的。首先,coreleft报告可用的内
存量。其次,malloc建立单字节堆变量p和双字节变量q。因为总是以
2字节整数倍进行分配的,所以单字节变量p实际上也占用两个字节的
空间。每个堆变量还需要 4个字节的头。这样,每分配一个堆变量,
内存容量就减少6个字节。接着,realloc把变量p扩大到3个字节,这 
就要求重新分配,返回的指针也指向了新地址050C。重新分配的堆变
量p占用了8个字节。包括它的头。尽管此时原来占用的 6具字节已经
释放了,但coreleft仍报告减少了 8个字节,而不是减少了两个字节。
这是因为coreleft报告的只是堆中最上面最后一个变量之后连续可用
的内存容量。也就是说由于堆的碎片化,coreleft报告的值是不准确
的。接着,程序又分配了一个单字节变量 r,它占用了第一次分配给
变量p后来又被释放的那6字节空间。在些之后,程序释放变量 q,在
变量r和p之间留下一个空洞。应该注意,分配r和释放q都不影响
coreleft 报告的值。最后,程序释放变量p。此时,coreleft报告的
值才是准确的,因为堆中只在其开始部分剩一个变量r了。
下面这个farheap。dem程序演示了如何从远堆中分配一个大于
64K字节的数组a。数组a是由9000具double型元素组成的,共需72K
字节。把函数farcalloc返回的远指针强制转换为huge指针, 以后就
可以用这个huge指针存取数组中的各个元素。#include<malloc.h>
void main(){
int i,n=9000;
double huge *a;
double sum;
a=(double huge *)farcalloc(n,sizeof(double));
for(i=0;i<n;a[i++]=i);
for(i=0,sum=0;i<n;sum+=a[i++]);
printf("a[i]=i for i=0。 n-1; n=%d\n",n);
printf("sum of all a[i]=%8.0f\n",sum);
printf("(n-1)n/2 =%1d \n",(long)n*(n-1)/2);
}
其它内存操作函数
Turbo C 中还提供了许多有关内存拷贝、比较、设置和查找的函
数。这些函数的说明都在头文件mem.h 中。一般来说,它们都不牵涉
到什么结构,而是直接对内存进行操作。这些函数可对简单的字节进
行操作,也可实现C 语言不直接支持的对数据结构的操作,如用一个
数组对另一个数组赋值,数组或C结构之间的比较等。
用于内存之间拷贝数据的Turbo C函数有如下5个:
void *_Cdecl memccpy(void *dest,const void *src,
int c,size_t n);
void *_Cdecl memcpy(void *dest,const void *src,
size_t n);
void *_Cdecl memmove(void *dest,const void *src,
size_t n);
void _Cdecl movmem(void *src,void *dest,unsigned length);
void _Cdecl movedata(unsigned srcseg,unsigned srcoff,
unsigned dstseg,unsigned dstoff,size_t n); 函数memcpy从源 src拷贝kn个字节到目dest。如果源和目有重叠
的地方,则结果不一定正确。
函数memccpy与memcpy类似,但若被拷贝的字节中有字符c,则在
拷贝完这个字符后也停止拷贝,返回的指针指向目dest中的下一个字
节位置。若n个字节全部拷贝完,则返回的指针为空。
函数memmove和movmem 也用于拷贝,但它们都解决了源和目重叠
的问题。函数movmem 一反通常“目=源”这样一个参数顺序,而是源
在前,目在后。
在小模式和中模式下,前面4 个拷贝函数所接收的源和目指针都
只能是近指针,不能用来拷贝远数据段内的数组。函数movedata克服
了这个缺陷,它允许指定源和目的段地址和偏移量,它没有解决源和
目重叠的问题,也要求源参数在前,目参数在后。
Turbo C Tools中的函数utmovmem与Turbo C的movedata是类似的,
但它自动解决了源和目的重叠问题。 void utmovmem(const char far *psource,char far *ptarget,
unsigned int length);
用于内存之间比较的Turbo C函数有如下两个: int _Cdecl memcmp(const void *s1,const void *s2,size_t n);
int _Cdecl memicmp(const void *s1,const void *s2,size_t n); 这两个函数都是比较两个字节数组的前n 个字节,根据s1是小于、
等于还是大于s2,返回值分别为小于0、等于0和大于0。但函数memcmp
是精确比较,把每个字节看作无符号8位数,而函数memicmp把每个字
节看作一个字符,忽略大小写的差别。
用于内存设置的Turbo C函数有如下两个: void *_Cdecl memset(void *s,int c,size_t n);
void _Cdecl setmem(void *dest,unsigned length,char value);
这两个函数都是设置一块内存区域为某一个字节值,参数顺序不
一样,返回值也不一样,但实际作用看不出有什么区别。
用于从一个内存块的头n个字节中查找某一个字符的Turbo C函数
是memchr: void *_Cdecl memchr(const void *s,int c,size_t n); 如果找到了,则返回的指针向字符c第1次出现的位置。如果找不
到,则返回的指针为空。

▲评论

› 网友 王树坡 () 于 2013-08-06 15:21:33 发表评论说:

受教了,谢谢您!
我是王树坡,刚从学校毕业,打算从事计算机行业,能得到您的指点吗~~~
1121140449
我的QQ

X 正在回复:
姓 名: 留下更多信息
性 别:
邮 件:
主 页:
Q Q:
来 自:
职 业:
评 论:


Valid HTML 4.01 Strict Valid CSS!
Copyleft.A!die Software Studio.ADSS
Power by webmaster@adintr.com