嵌入式

C/C++与汇编混合编程简介

2019-07-13 07:06发布

站内文章 / 嵌入式Linux
13915 0 922
声明：1、本文内容为本人学习嵌入式linux所遇问题后，为方便以后学习查阅转载所得，若能助人，也算报答前人之恩！    2、 如若侵犯原创作者权益，请与我联系，本人愿意承担责任！
原博客位置

1. 简介

     当需要C/C++与汇编混合编程时，可以有以下两种处理策略：
  • 若汇编代码较短，则可在C/C++源文件中直接内嵌汇编语言实现混合编程。
  • 若汇编代码较长，可以单独写成汇编文件，最后以汇编文件的形式加入项目中，通过ATPCS规定与C程序相互调用及访问。

2. 内嵌汇编语言指令

    用C/C++程序嵌入汇编程序中可以实现一些高级语言没有的功能，提高程序执行效率。armcc编译器的内嵌汇编器支持ARM指令集，tcc编译器的内嵌汇编器支持Thumb指令集。

2.1 内嵌汇编指令的语法格式

      在ARM的C语言程序中可以使用关键字__asm来加入一段汇编语言的程序，格式如下：
 [cpp] view plaincopy
  1. __asm  
  2. {  
  3.     指令 [;指令]      /* comments */  
  4.     ...  
  5.   
  6.     指令  
  7. }  

      其中，{ }中的指令都为汇编指令，一行允许写多条汇编指令语句，指令语句之间要用分号隔开。在汇编指令段中，注释语句采用C语言的注释格式。ARM C++程序中除了可以使用关键字__asm来标识一段内嵌汇编指令程序外，还可以使用关键词asm来表示一段内嵌汇编指令，格式如下：
asm ("指令");
     其中，asm后面的括号中必须是一条汇编指令语句，并且不能包含注释语句。

2.2 使能/禁止IRQ中断实例

[cpp] view plaincopy
  1. void enable_IRQ(void) //使能中断程序  
  2. {  
  3.     int tmp;              //定义临时变量，后面使用  
  4.     __asm                 //内嵌汇编程序的关键词  
  5.     {  
  6.         MRS tmp, CPSR     //把状态寄存器加载给tmp  
  7.         BIC tmp, tmp, #80 //将IRQ控制位清0  
  8.         MSR CPSR_c, tmp   //加载程序状态寄存器  
  9.     }  
  10. }  
  11.   
  12. void disable_IRQ(void) //禁止中断程序  
  13. {  
  14.     int tmp;              //定义临时变量，后面使用  
  15.     __asm                 //内嵌汇编程序的关键词  
  16.     {  
  17.         MRS tmp, CPSR     //把状态寄存器加载给tmp  
  18.         ORR tmp, tmp, #80 //将IRQ控制位置1  
  19.         MSR CPSR_c, tmp   //加载程序状态寄存器  
  20.     }  
  21. }  

2.3 内嵌汇编注意事项      

      后缀.S文件中的汇编指令是用armasm汇编器进行汇编的，而C语言程序中的内嵌汇编指令则是用内嵌汇编器进行汇编的。这两种汇编器存在一定的差异，所以在内嵌汇编时要注意以下几点：

2.3.1 小心使用物理寄存器

      必须小心使用物理寄存器，如R0～R3、IP(R12)、LR(R14)和CPSR中的N、Z、C、V标志位。因为计算汇编代码中的C表达式时，可能使用这些物理寄存器，并会修改N、Z、C、V标志位。
      如计算y=x+x/y;
[cpp] view plaincopy
  1. __asm  
  2. {  
  3.     MOV R0, x         //把x的值给R0  
  4.     ADD y, R0, x/y    //计算x/y时R0的值会被修改  
  5. }  


2.3.2 内嵌汇编程序中允许使用C变量        

       在计算x/y时R0会被修改，从而影响R0+x/y的结果。内嵌汇编程序中允许使用C变量，用C变量来代替寄存器R0可以解决上述问题。这时内嵌汇编器将会为变量var分配合适的存储单元，从而避免冲突的发生。如果内嵌汇编器不能分配合适的存储单元，它将会报告错误。
[cpp] view plaincopy
  1. int var;  
  2. __asm  
  3. {  
  4.     MOV var, x      //把x的值给R0  
  5.     ADD y, var, x/y //计算x/y时R0的值会被修改  
  6. }  

2.3.3 不需要保存和恢复用到的寄存器

     对于在内嵌汇编语言程序中用到的寄存器，编译器在编译时会自动保存和恢复这些寄存器，用户不用保存和恢复这些寄存器。除了CPSR和SPSR寄存器外，其他物理寄存器在读之前必须先赋值，否则编译器会报错。
[cpp] view plaincopy
  1. int fun (int x)  
  2. {  
  3.     __asm  
  4.     {  
  5.         STMFD SP!, {R0}   //保存R0，先读后写，汇编出错  
  6.         ADD R0, x, #1  
  7.         EOR x, R0, x  
  8.         LDMFD SP!, {R0}   //多余的  
  9.     }  
  10.     return x;  
  11. }  

3. 汇编与C/C++程序的变量相互访问

3.1 汇编程序访问C/C++程序变量

     在C/C++程序中声明的全局变量可以被汇编程序通过地址间接访问。具体访问方法/步骤如下：
     1) 在C/C++程序中声明全局变量。
     2) 在汇编程序中使用IMPORT/EXTERN伪指令声明引用该全局变量。
     3) 使用LDR伪指令读取该全局变量的内存地址。
     4) 根据该数据的类型，使用相应的LDR指令读取该全局变量；使用相应的STR指令存储该全局变量的值。对于不同类型的变量，需要采用不同选项的LDR和STR指令，如下表所示。 C/C++语言中的变量类型
 带后缀的LDR和STR指令
 描述
 unsigned char
 LDRB/STRB
 无符号字符型
 unsigned short
 LDRH/STRH
 无符号短整型
 unsigned int
 LDR/STR
 无符号整型
 char
 LDRSB/STRSB
 字符型(8位)
 short
 LDRSH/STRSH
 短整型(16位)
      对于结构，如果知道各个数据项的偏移量，可以通过存储/加载指令访问。如果结构所占空间小于8个字，可以使用LDM和STM一次性读写。
     读取C的一个全局变量，并进行修改，然后保存新的值到全局变量中: [cpp] view plaincopy
  1. AREA Example4, CODE, READONLY  
  2.      EXPORT AsmAdd  
  3.      IMPORT g_cVal      @声明外部变量g_cVal,在C中定义的全局变量  
  4. Add  
  5.      LDR R1, =g_cVal    @装载变量地址  
  6.      LDR R0, [R1]       @从地址中读取数据到R0  
  7.      ADD R0, R0, #1     @加1操作  
  8.      STR R0, [R1]       @保存变量值  
  9.      MOV PC, LR         @程序返回  
  10. END  

3.2 C/C++程序访问汇编程序数据

     在汇编程序中声明的数据可以被C/C++程序所访问。具体访问方法/步骤如下：
     1) 在汇编程序中用EXPORT/GLOBAL伪指令声明该符号为全局标号，可以被其他文件应用。
     2) C/C++程序中定义相应数据类型的指针变量。
     3) 对该指针变量赋值为汇编程序中的全局标号，利用该指针访问汇编程序中的数据。     假设在汇编程序中定义了一块内存区域，并保存一串字符，汇编代码如下：
  [cpp] view plaincopy
  1. EXPORT Message        @声明全局标号  
  2. Message DCB "HELLO$"  @定义了5个有效字符，$为结束符  

[cpp] view plaincopy
  1. extern char* Message;  
  2. int MessageLength()  
  3. {  
  4.     int Length = 0;  
  5.     char *pMessage;         //定义字符指针变量  
  6.     pMessage = Message;     //指针指向Message 内存块的首地址  
  7.       
  8.     /*while循环，统计字符串的长度*/  
  9.     while(*pMessage != '$') //$为字符串的结束符  
  10.     {  
  11.         Length++;  
  12.         pMessage++;  
  13.     }  
  14.     return(Length); //返回字符串的长度  
  15. }  


4. 汇编与C/C++程序的函数相互调用

    C/C++程序和ARM汇编程序之间相互调用必须遵守ATPCS（ARM/Thumb Procedure Call Standard）规则。使用ADS的C语言编译器编译的C语言子程序会自动满足用户指定的ATPCS类型。而对于汇编语言来说，完全要依赖用户来保证各个子程序满足选定的ATPCS类型。具体来说，汇编程序必须满足以下3个条件才能实现与C语言的相互调用。
     1) 在子程序编写时必须遵守相应的ATPCS规则。
     2) 堆栈的使用要遵守相应的ATPCS规则。
     3) 在汇编编译器中使用-atpcs选项。

4.1 ATPCS基本规则

      ATPCS基本规则见ATPCS。

4.2 C程序调用汇编程序

     汇编程序的设置要遵循ATPCS规则，保证程序调用时参数的正确传递，在这种情况下，C程序可以调用汇编子函数。C程序调用汇编程序的方法如下：
      1) 汇编程序中使用EXPORT伪指令声明本子程序可外部使用，使其他程序可调用该子程序。
      2) 在C语言程序中使用extern关键字声明外部函数(声明要调用的汇编子程序)，才可调用此汇编的子程序。
[cpp] view plaincopy
  1. #include   
  2. extern void strcopy(char *d, const char *s); //声明外部函数，即要调用的汇编子程序  
  3. int main(void)  
  4. {  
  5.     const char *srcstr = "First ource";          //定义字符串常量  
  6.     char dststr[] = "Second string-destination"; //定义字符串变量  
  7.     printf("Before copying：  ");  
  8.     printf("src=%s, dst=%s ", srcstr, dststr);  //显示源字符串和目标字符串的内容  
  9.     strcopy(dststr, srcstr);                     //调用汇编子程序R0=dststr, R1=srcstr  
  10.     printf("After copying：  ");  
  11.     printf("src=%s, dst=%s ", srcstr, dststr);  //显示复制后的结果  
  12.     return(0);  
  13. }  

     strcopy实现代码如下： [cpp] view plaincopy
  1.       AREA Example, CODE, READONLY @声明代码段Example  
  2.            EXPORT strcopy          @声明strcopy，以便外部函数调用  
  3.   
  4. strcopy     @ R0为目标字符串的地址, R1为源字符串的地址  
  5.   
  6.            LDRB R2, [R1], #1    @读取字节数据，源地址加1  
  7.            STRB R2, [R0], #1    @保存读取的1字节数据，目标地址加1  
  8.            CMP R2, #0           @判断字符是否复制完毕  
  9.            BNE strcopy          @没有复制完，继续循环复制  
  10.            MOV PC, LR   


4.3 汇编程序调用C程序

      汇编程序设置要遵循APTCS规则，保证程序调用时参数的正确传递。汇编程序调用C程序的方法如下：
      1) 在汇编程序中使用IMPORT伪指令声明将要调用的C程序函数。
      2) 在调用C程序时，要正确设置入口参数，然后使用BL指令调用。
[cpp] view plaincopy
  1. int sum(int a, int b, int c, int d, int e)  
  2. {  
  3.     return(a+b+c+d+e); //返回5个变量的和  
  4. }  

[cpp] view plaincopy
  1.  AREA Example, CODE, READONLY  
  2.      IMPORT sum      @ 声明外部标号sum，即C函数sum()  
  3.      EXPORT CALLSUM  
  4. UM  
  5.      STMFD SP!, {LR}    @LR寄存器入栈  
  6.      MOV R0, #1         @设置sum函数入口参数，R0为参数a  
  7.      MOV R1, #2         @R1为参数b  
  8.      MOV R2, #3         @R2为参数c  
  9.      MOV R3, #5         @参数 e=5，保存到堆栈中  
  10.      STR R3, {SP, #-4}!  
  11.      MOV R3, #4         @R3为参数d, d=4  
  12.      BL sum             @调用C程序中的sum函数，结果放在R0中  
  13.      ADD SP, SP, #4     @调整堆栈指针  
  14.      LDMFD SP, {PC}     @程序返回  
  15. END  

     以上程序使用了5个参数，分别使用寄存器R0存储第1个参数，R1存储第2个参数，R2存储第3个参数，R3存储第4个参数，第5个参数利用堆栈传送。由于利用了堆栈传递参数，在程序调用结束后要调整堆栈指针。汇编程序中调用了C程序的sum子函数，实现了1+2+3+4+5，最后相加结果保存在R0寄存器中。













热门文章