DIY编程器网

标题: Keil C51的一些有趣特性 [打印本页]

---

作者: liyf    时间: 2012-1-27 14:36
标题: Keil C51的一些有趣特性
    首先得说的是我是菜鸟，在此论坛上学了很多的东东。但是今年以来，论坛上似乎没有了去年一大帮高手讨论问题的场面了，似乎失去了往日的风光了。在此我那出我近日一些不成熟的想法，希望大家斧正。有啥不正确的，请一定告之与我。
    Keil C51的一些有趣特性
    Keil c51号称作为51系列单片机最好的开发环境，大家一定都很熟悉。它的一些普通的特性大家也都了解，（书上也都说有）如：因为51内的RAM很小，C51的函数并不通过堆栈传递参数（重入函数除外），局部变量也不存储在堆栈中，而是存在于固定的RAM中及寄存器中。那么看一下下面的程序。
void fun1(unsigned char i)
{
       …
}
    正常情况参数i通过R7传入函数，那么它的实际地址在什么地方呢？就是R7吗？回答这个问题之前我们先来了解keil c51的几个有趣的特性（不考虑重入函数）。

    一、函数在调用前定义与在调用后定义产生的代码是有很大差别的（特别是在优化级别大于3级时）。（本人也不太清楚为什么，大概因为在调用前定义则调用函数已经知道被调用函数对寄存器的使用情况，则可对函数本身进行优化；而在调用后进行定义则函数不知被调用函数对寄存器的使用情况，它默认被调用函数对寄存器（ACC、 B、 DPH、 DPL、 PSW、 R0、 R1、 R2、 R3、R 4、 R5、, R6、 R7）都已经改变，因此不在这些寄存器中存入有效的数据）
    二、函数调用函数时除在堆栈中存入返回地址之外，不在堆栈中保存其它任何寄存器（ACC、 B、 DPH、 DPL、 PSW、 R0、 R1、 R2、 R3、R 4、 R5、, R6、 R7）的内容。（除非被调用函数使用了using特性）
    三、中断函数是一个例外，它会计算自身及它所调用的函数对寄存器（ACC、 B、 DPH、 DPL、 PSW、 R0、 R1、 R2、 R3、R 4、 R5、, R6、 R7）的改变，并保存相应它认为被改变了的寄存器。
    四、使用C写程序时，尽量少使用using n (n=0,1,2,3)特性。（这个特性在本人使用的过程中存在一些问题，不知算不算是一个小bug）
    以下的试验都是在（环境 keil c51 v7.20）中，优化级为default下完成。
    先看第一个特性问题。
    例1：
void fun2(void)
{
}

void fun1(unsigned char i)
{
       fun2();
       while(i--);
}
它的汇编代码如下：
; void fun2(void)

       RSEG  ?PR?fun2?TEST
fun2:
                     ; SOURCE LINE # 12
; {
                     ; SOURCE LINE # 13
; }
                     ; SOURCE LINE # 14
       RET      
; END OF fun2

;
; void fun1(unsigned char i)

       RSEG  ?PR?_fun1?TEST
_fun1:
       USING    0
                     ; SOURCE LINE # 16
;---- Variable 'i?240' assigned to Register 'R7' ----
; {
                     ; SOURCE LINE # 17
;     fun2();
                     ; SOURCE LINE # 18
       LCALL       fun2
?C0003:
;     while(i--);
                     ; SOURCE LINE # 19
       MOV         R6,AR7
       DEC         R7
       MOV         A,R6
       JNZ         ?C0003
; }
                     ; SOURCE LINE # 20
?C0005:
       RET      
; END OF _fun1
    从中可以看到fun2()在fun1()前先定义，fun1()知道fun2()对寄存器的使用情况，知道R7没有改变，而参数i存于R7中，即i既是R7。（;---- Variable 'i?140' assigned to Register 'R7' ----）

    看另一情况
void fun2(void);
void fun1(unsigned char i)
{
       fun2();
       while(i--);
}

void fun2(void)
{
}
    汇编代码如下：
; void fun1(unsigned char i)

       RSEG  ?PR?_fun1?TEST
_fun1:
       USING    0
                     ; SOURCE LINE # 14
       MOV         i?140,R7
; {
                     ; SOURCE LINE # 15
;     fun2();
                     ; SOURCE LINE # 16
       LCALL       fun2
?C0002:
;     while(i--);
                     ; SOURCE LINE # 17
       MOV         R7,i?140
       DEC         i?140
       MOV         A,R7
       JNZ         ?C0002
; }
                     ; SOURCE LINE # 18
?C0004:
       RET      
; END OF _fun1

;
; void fun2(void)

       RSEG  ?PR?fun2?TEST
fun2:
                     ; SOURCE LINE # 20
; {
                     ; SOURCE LINE # 21
; }
                     ; SOURCE LINE # 22
       RET      
; END OF fun2
    fun2()在fun1()调用后定义，因fun1()调用fun2()时不知道fun2()对寄存器的使用情况，则认为fun2()改变了所有的寄存器（ACC、 B、 DPH、 DPL、 PSW、 R0、 R1、 R2、 R3、R 4、 R5、, R6、 R7）。因为fun1()认为fun2()改变了寄存器的值（包括R7），因此i虽然通过R7传递，但因已因调用fun2()而改变，所以不能再存在R7了，而上在RAM中额外的用一个Byte来存储。
    这也就解释了在开始时的那个问题，参数i的存储是看问题而定的。
    是否很有趣呢。在节约RAM方面，这可是一个很有用的特性哦。（大家是否也为自己的节省了1Byte的RAM）
    这个例子还解释了第二个特性，函数调用函数时除在堆栈中存入返回地址之外，不在堆栈中保存其它任何寄存器（ACC、 B、 DPH、 DPL、 PSW、 R0、 R1、 R2、 R3、R 4、 R5、R6、R7）的内容。函数在调用函数前，尽量不在这些寄存器中保存有效的数据，实在无法避免，则把有效数据存入固定的RAM中。
    对于中断函数问题，当你看到下面的程序相差55 Byte时，不知你会怎么想的。
    例2：
void OSTimeDly(void);  //using 1
static void Timer0OVInt(void) interrupt 1 //using 1
{
       TR0 = 0;
       TH0 = 100;
       TL0 = 100;
       TR0 = 1;

       OSTimeDly();
}

void OSTimeDly(void)  //using 1
{

}
与
void OSTimeDly(void)  //using 1
{

}

static void Timer0OVInt(void) interrupt 1 //using 1
{
       TR0 = 0;
       TH0 = 100;
       TL0 = 100;
       TR0 = 1;

       OSTimeDly();
}
    它们的汇编代码分别是，
; static void Timer0OVInt(void) interrupt 1 //using 1

       RSEG  ?PR?Timer0OVInt?TEST
       USING    0
Timer0OVInt:
       PUSH        ACC
       PUSH     B
       PUSH        DPH
       PUSH        DPL
       PUSH        PSW
       MOV         PSW,#00H
       PUSH        AR0
       PUSH        AR1
       PUSH        AR2
       PUSH        AR3
       PUSH        AR4
       PUSH        AR5
       PUSH        AR6
       PUSH        AR7
       USING    0
                     ; SOURCE LINE # 24
; {
;     TR0 = 0;
                     ; SOURCE LINE # 26
       CLR         TR0
;     TH0 = 100;
                     ; SOURCE LINE # 27
       MOV         TH0,#064H
;     TL0 = 100;
                     ; SOURCE LINE # 28
       MOV         TL0,#064H
;     TR0 = 1;
                     ; SOURCE LINE # 29
       SETB        TR0
;
;        OSTimeDly();
                     ; SOURCE LINE # 31
       LCALL       OSTimeDly
; }
                     ; SOURCE LINE # 32
       POP         AR7
       POP         AR6
       POP         AR5
       POP         AR4
       POP         AR3
       POP         AR2
       POP         AR1
       POP         AR0
       POP         PSW
       POP         DPL
       POP         DPH
       POP      B
       POP         ACC
       RETI      
; END OF Timer0OVInt

;
;
; void OSTimeDly(void)  //using 1

       RSEG  ?PR?OSTimeDly?TEST
OSTimeDly:
                     ; SOURCE LINE # 35
; {
                     ; SOURCE LINE # 36
;
; }
                     ; SOURCE LINE # 38
       RET      
; END OF OSTimeDly
及
; void OSTimeDly(void)  //using 1

       RSEG  ?PR?OSTimeDly?TEST
OSTimeDly:
                     ; SOURCE LINE # 22
; {
                     ; SOURCE LINE # 23
;
; }
                     ; SOURCE LINE # 25
       RET      
; END OF OSTimeDly

CSEG     AT       0000BH
       LJMP       Timer0OVInt

;
; static void Timer0OVInt(void) interrupt 1 //using 1

       RSEG  ?PR?Timer0OVInt?TEST
       USING    0
Timer0OVInt:
                     ; SOURCE LINE # 27
; {
;     TR0 = 0;
                     ; SOURCE LINE # 29
       CLR         TR0
;     TH0 = 100;
                     ; SOURCE LINE # 30
       MOV         TH0,#064H
;     TL0 = 100;
                     ; SOURCE LINE # 31
       MOV         TL0,#064H
;     TR0 = 1;
                     ; SOURCE LINE # 32
       SETB        TR0
;
;        OSTimeDly();
                     ; SOURCE LINE # 34
       LCALL       OSTimeDly
; }
                     ; SOURCE LINE # 35
       RETI      
; END OF Timer0OVInt

    这个例子的汇编代码很好的解释了上面的特性1及3。
    至于第四个特性，值得特别说明一下。看下例：
    例3：
void OSTimeDly(void);
static void Timer0OVInt(void) interrupt 1 using 0
{
       TR0 = 0;
       TH0 = 100;
       TL0 = 100;
       TR0 = 1;

       OSTimeDly();
}

void OSTimeDly(void) // using 0
{

}
    它的汇编代码是
; static void Timer0OVInt(void) interrupt 1 using 0
       RSEG  ?PR?Timer0OVInt?TEST
       USING    0
Timer0OVInt:
       PUSH        ACC
       PUSH     B
       PUSH        DPH
       PUSH        DPL
       PUSH        PSW
       USING    0
       MOV         PSW,#00H
                     ; SOURCE LINE # 24
; {
;     TR0 = 0;
                     ; SOURCE LINE # 26
       CLR         TR0
;     TH0 = 100;
                     ; SOURCE LINE # 27
       MOV         TH0,#064H
;     TL0 = 100;
                     ; SOURCE LINE # 28
       MOV         TL0,#064H
;     TR0 = 1;
                     ; SOURCE LINE # 29
       SETB        TR0
;
;        OSTimeDly();
                     ; SOURCE LINE # 31
       LCALL       OSTimeDly
; }
                     ; SOURCE LINE # 32
       POP         PSW
       POP         DPL
       POP         DPH
       POP      B
       POP         ACC
       RETI      
; END OF Timer0OVInt

;
; void OSTimeDly(void) // using 0

       RSEG  ?PR?OSTimeDly?TEST
OSTimeDly:
                     ; SOURCE LINE # 34
; {
                     ; SOURCE LINE # 35
;
; }
                     ; SOURCE LINE # 37
       RET      
; END OF OSTimeDly
    此例中除了中断函数使用了using 0之外，与上例中的程序并无区别，但是汇编的代码相差却很大。此例中的汇编代码不再保存R0 ---- R7的值。（默认keil c51中的函数使用的是0寄存器组，当中断函数使用using n时，n = 1,2,3或许是对的，但n=0时，程序就已经存在了bug（只有中断函数及其所调用的函数并没有改变R0 ---- R7的值时，这个bug不会表现出来））
    一个结论是，在中断函数中如果使用了using n，则中断不再保存R0----R7的值。
    由此可以推论出，一个高优先级的中断函数及一个低优先级的中断函数同时使用了using n，（n = 0,1,2,3）当n相同时，这个存在的bug 是多么的隐蔽。（这恰是使人想象不到的）
    最后再来看一例
    例4：
void OSTimeDly(unsigned char i);
static void Timer0OVInt(void) interrupt 1 using 1
{
       TR0 = 0;
       TH0 = 100;
       TL0 = 100;
       TR0 = 1;

       OSTimeDly(5);
}

void OSTimeDly(unsigned char i)   // using 0
{
       while(i--);
}
    汇编的结果
; static void Timer0OVInt(void) interrupt 1 using 1

       RSEG  ?PR?Timer0OVInt?TEST
       USING    1
Timer0OVInt:
       PUSH        ACC
       PUSH     B
       PUSH        DPH
       PUSH        DPL
       PUSH        PSW
       USING    1
       MOV         PSW,#08H
                     ; SOURCE LINE # 25
; {
;     TR0 = 0;
                     ; SOURCE LINE # 27
       CLR         TR0
;     TH0 = 100;
                     ; SOURCE LINE # 28
       MOV         TH0,#064H
;     TL0 = 100;
                     ; SOURCE LINE # 29
       MOV         TL0,#064H
;     TR0 = 1;
                     ; SOURCE LINE # 30
       SETB        TR0
;
;        OSTimeDly(5);
                     ; SOURCE LINE # 32
       MOV         R7,#05H
       LCALL       _OSTimeDly
; }
                     ; SOURCE LINE # 33
       POP         PSW
       POP         DPL
       POP         DPH
       POP      B
       POP         ACC
       RETI      
; END OF Timer0OVInt

;
; void OSTimeDly(unsigned char i) // using 0

       RSEG  ?PR?_OSTimeDly?TEST
_OSTimeDly:
       USING    0
                     ; SOURCE LINE # 35
;---- Variable 'i?441' assigned to Register 'R7' ----
; {
                     ; SOURCE LINE # 36
?C0009:
;     while(i--);
                     ; SOURCE LINE # 37
       MOV         R6,AR7
       DEC         R7
       MOV         A,R6
       JNZ         ?C0009
; }
                     ; SOURCE LINE # 38
?C0011:
       RET      
; END OF _OSTimeDly

    注意OSTimeDly()中此处的汇编代码，
       MOV         R6,AR7
       DEC         R7
    因为Timer0OVInt（）函数使用的寄存器组是1 (using 1)，而OSTimeDly()默认使用0寄存器组（默认使用的寄存器组是不会用代码显示改变的）。因此Timer0OVInt（）调用OSTimeDly()时寄存器组仍然是1组，R7的地址是15，而AR7的地址为OSTimeDly()所使用的寄存器组中R7的地址，在0寄存器组中为7。因此当AR7为0时，这是一个死循环。
    结论，使用不同寄存器组的函数（特殊情况外）不能相互调用  
                                

---

欢迎光临 DIY编程器网 (http://diybcq.com/)

Powered by Discuz! X3.2