混合使用C、C++和汇编语之： C、C++ 和 ARM 汇编语言之间的调用

admin

        12.4  C、C++ 和 ARM 汇编语言之间的调用

        本节提供一些示例，显示如何从C++调用C和汇编语言代码，以及从C和汇编语言调用 C++ 代码。其中包括调用约定和数据类型。主要包括下面内容：
        ·  相互调用的一般规则；
        ·  C++语言的特定信息；
        ·  调用示例。
         
        只要遵循正确的过程调用标准AAPCS，就可以混合调用C、C++和汇编语言例程。有关 AAPCS 的更多信息，请参阅ARM相关文档。
         
        12.4.1  相互调用的一般规则

        以下一般规则适用于C、C++和汇编语言之间的调用。有关的详细信息，请参阅ARM开发相关文档。
         
        嵌入式汇编程序以及其与ARM嵌入式应用程序二进制接口（BSABI，Application Binary Interface for the ARM Architecture）的兼容使得混合语言编程更易于实现。它们可提供以下功能：
         
        ·  使用__cpp关键字进行名称延伸；
        ·  传递隐含this参数的方式；
        ·  调用虚函数的方式；
        ·  引用的表示；
        ·  具有基类或虚成员函数的C++类的类型布局；
        ·  非POD（Plain Old Data）结构的类对象传递。
         
        以下一般规则适用于混合语言编程：
        ·  使用C调用约定。
        ·  在C++中，非成员函数可以声明为extern "C"，以指定它们有C链接。带有C链接意味着定义函数的符号未延伸。C链接可以用于以一种语言实现函数，然后用另一种语言调用它。
        ·  汇编语言模块所必须符合的AAPCS调用标准，应当适合于应用程序所使用的存储器模型。
        以下规则适用于从C和汇编语言调用C++函数：
        ·  要调用全局（非成员）C++函数，应将它声明为extern "C"，以提供C链接。
        ·  成员函数（静态和非静态）总是有已延伸的名称。使用嵌入式汇编程序的__cpp关键字，可以不必手工寻找已延伸的名称。
        ·  不能从C调用C++内联函数，除非确保C++编译器生成了函数的外联副本。例如，取得函数地址将导致生成外联副本。
        ·  非静态成员函数接受隐含this参数作为r0中的第一个自变量，或作为r1中第二个自变量（如果函数返回非int类结构）。静态成员函数不接受隐含this参数。
         
        12.4.2  C++的特定信息

        本节主要介绍一些专门适用于C++的内容。
        （1）C++调用约定
        ARM C++使用与ARM C相同的调用约定，但在下面的情况下，调用规则有所不同：
        ·  调用非静态成员函数时，隐含的this参数是第一个自变量，或者是第二个自变量（如果被调用函数返回非int类的struct）。这可能在将来的版本中有所变化。
         
        （2）C++数据类型
        ARM C++使用与ARM C相同的数据类型，但在以下几种情况下，情况有所不同：
        ·  如果struct或class类型的C++对象没有基类或虚函数，则它们的布局与ARM C相同。如果这样的struct没有用户定义的复制赋值运算符或用户定义的析构函数，则它是POD结构。
        ·  引用表示为指针。
        ·  C函数指针和C++（非成员）函数指针没有区别。
         
        （3）符号名称延伸
        链接程序将取消信息中符号名称的延伸。
        在C++程序中，C名称必须声明为extern "C"。ARM ISO C头文件已经完成此操作。详细信息请参阅ARM相关文档。
         
        12.4.3  混合编程调用举例

        汇编程序、C程序以及C++程序相互调用时，要特别注意遵守相应的AAPCS。下面一些例子具体说明了在这些混合调用中应注意遵守的AAPCS规则。这些示例程序默认为使用非软件栈检查的ATPCS规则，因为它们执行栈操作时不检查栈溢出。
         
        （1）从C调用汇编语言
        下面的程序显示如何在C程序中调用汇编语言子程序，该段代码实现了将一个字符串复制到另一个字符串。
         
        #include <stdio.h>
        extern void strcopy(char *d, const char *s);
        int main()
        {   const char *srcstr = "First string - source ";
            char dststr[] = "Second string - destination ";
        /* 下面将dststr作为数组进行操作 */
            printf("Before copying:\n");
            printf("  %s\n  %s\n",srcstr,dststr);
            strcopy(dststr,srcstr);
            printf("After copying:\n");
            printf("  %s\n  %s\n",srcstr,dststr);
            return (0);
        }
         
        下面为调用的汇编程序。
         
            PRESERVE8
            AREA    SCopy, CODE, READONLY
            EXPORT strcopy
        Strcopy ;r0指向目的字符串
        ;r1指向源字符串
            LDRB r2, [r1],#1 ;加载字节并更新源字符串指针地址
            STRB r2, [r0],#1 ;存储字节并更新目的字符串指针地址
            CMP r2, #0 ;判断是否为字符串结尾
            BNE strcopy ;如果不是，程序跳转到strcopy继续拷贝
            MOV pc,lr ;程序返回
            END
         
        按以下步骤从命令行编译该示例：
        ① 输入armasm -g scopy.s编译汇编语言源代码。
        ② 输入armcc -c -g strtest.c编译C源代码。
        ③ 输入armlink strtest.o scopy.o -o strtest链接目标文件。
        ④ 将ELF/DWARF2兼容调试器与相应调试目标配合使用，运行映像。
         
        （2）汇编语言调用C程序
        下面的例子显示了如何从汇编语言调用C程序。
        下面的子程序段定义了C语言函数。
         
        int g(int a, int b, int c, int d, int e)
        {
                        return a + b + c + d + e;
        }
         
        下面的程序段显示了汇编语言调用。假设程序进入f时，r0中的值为i。
         
          ; int f(int i) { return g(i, 2*i, 3*i, 4*i, 5*i); }
          PRESERVE8
          EXPORT f
          AREA f, CODE, READONLY
          IMPORT g // 声明C程序g()
          STR lr, [sp, #-4]! // 保存返回地址 lr
          ADD r1, r0, r0 // 计算2*i(第2个参数)
          ADD r2, r1, r0 // 计算3*i(第3个参数)
          ADD r3, r1, r2 // 计算5*i
          STR r3, [sp, #-4]! // 第五个参数通过堆栈传递
          ADD r3, r1, r1 // 计算4*i(第4个参数)
          BL g // 调用C程序
          ADD sp, sp, #4 // 从堆栈中删除第5个参数
          LDR pc, [sp], #4 // 返回
          END
         
        （3）从C++调用C
        下面的例子显示了如何从C++程序中调用C函数。
        下面的C++程序调用了C程序。
         
        struct S { // 本结构没有基类和虚函数
         
              S(int s):i(s) { }
              int i;
        };
        extern "C" void cfunc(S *);
        // 被调用的C函数使用extern“C”声明
        int f(){
               S s(2); // 初始化 &#39;s&#39;
               cfunc(&s); // 调用C函数 &#39;cfunc&#39; 将改变 &#39;s&#39;
               return si*3;
        }
         
        下面显示了被调用的C程序代码。
         
        struct S {
              int i;
        };
        void cfunc(struct S *p) {
        /*定义被调用的C功能 */
              p->i += 5;
        }
         
        （4）从C++中调用汇编
        下面的例子显示了如何从C++中调用汇编程序。
        下面的例子为调用汇编程序的C++代码。
         
        struct S { // 本结果没有基类和虚拟函数
        //
              S(int s) : i(s) { }
              int i;
        };
        extern "C" void asmfunc(S *); // 声明被调用的汇编函数
         
        int f() {
               S s(2); // 初始化结构体 &#39;s&#39;
               asmfunc(&s); // 调用汇编子程序 &#39;asmfunc&#39;
         
               return s.i * 3;
        }
         
        下面是被调用的汇编程序。
         
             PRESERVE8
             AREA Asm, CODE
             EXPORT asmfunc
        asmfunc                // 被调用的汇编程序定义
             LDR r1, [r0]      
             ADD r1, r1, #5
             STR r1, [r0]
             MOV pc, lr
             END
         
        （5）从C中调用C++
        下面的例子显示了如何从C++代码中调用C程序。
        下面的代码显示了被调用C++代码。
         
        struct S {        // 本结构没有基类和虚拟函数
              S(int s) : i(s) { }
              int i;
        };
        extern "C" void cppfunc(S *p) {   
        // 定义被调用的C++代码
        // 连接了C功能
              p->i += 5;                //
        }
         
        调用了C++代码的C函数。
         
        struct S {
              int i;
        };
        extern void cppfunc(struct S *p);
        /* 声明将会被调用的C++功能 */
        int f(void) {
               struct S s;
               s.i = 2;                /* 初始化S */
               cppfunc(&s);            /* 调用cppfunc函数，该函数可能改变S的值 */
               return s.i * 3;
        }
         
        （6）从汇编中调用C++程序
        下面的代码显示了如何从汇编中调用C++程序。
        下面是被调用的C++程序。
         
        struct S {           // 本结构没有基类和虚拟函数
              S(int s) : i(s) { }
              int i;
        };
        extern "C" void cppfunc(S * p) {
        // 定义被调用的C++功能
        // 功能函数体
              p->i += 5;
        }
         
        在汇编语言中，声明要调用的C++功能，使用带连接的跳转指令调用C++功能。
         
            AREA Asm, CODE
            IMPORT cppfunc ;声明被调用的 C++ 函数名
         
            EXPORT   f
        f
            STMFD  sp!,{lr}
            MOV    r0,#2
            STR    r0,[sp,#-4]! ;初始化结构体
            MOV    r0,sp ;调用参数为指向结构体的指针
            BL     cppfunc ;调用C++功能&#39;cppfunc&#39;
         
            LDR    r0, [sp], #4
            ADD    r0, r0, r0,LSL #1
            LDMFD  sp!,{pc}
            END
         
        （7）在C和C++函数间传递参数
        下面的例子显示了如何在C和C++函数间传递参数。
        下面的代码为C++函数。
         
        extern "C" int cfunc(const int&);
        // 声明被调用的C函数
        extern "C" int cppfunc(const int& r) {
        // 定义将被C调用的C++函数
              return 7 * r;
        }
        int f() {
              int i = 3;
              return cfunc(i); // 相C函数传参
        }
         
        下面为C函数。
         
        extern int cppfunc(const int*);   
        /* 声明将被调用的C++函数 */
        int cfunc(const int *p) {      
        /*定义被C++调用的C函数*/
             int k = *p + 4;
             return cppfunc(&k);
        }
         
        （8）从C或汇编语言调用C++
        下面的例子综合显示了如何从C或汇编语言中调用非静态、非虚的C++成员函数。可以使用编译器编译出的汇编程序查找已延伸的函数名。
        下面是被调用的C++成员函数。
         
        struct T {
              T(int i) : t(i) { }
              int t;
              int f(int i);
        };
        int T::f(int i) { return i + t; }   
        // 定义将被C调用的C++功能函数
        extern "C" int cfunc(T*);
        // 声明将被C++调用的C函数
        int f() {
              T t(5);                    // create an object of type T
              return cfunc(&t);
        }
         
        下面为调用C++的C语言函数。
         
        struct T;
        extern int _ZN1T1fEi(struct T*, int);
              /* 被调用的C++函数名 */
        int cfunc(struct T* t) {   
        /* 定义被C++调用的C函数 */
              return 3 * _ZN1T1fEi(t, 2);    /* 实现3乘以t->f(2)功能 */
        }
         
        下面为调用C++的汇编函数。
         
             EXPORT cfunc
             AREA foo, CODE
             IMPORT  _ZN1T1fEi
        cfunc
             STMFD   sp!,{lr} ;此时r0已经包含了指向对象的指针
             MOV r1, #2
             BL _ZN1T1fEi
             ADD r0, r0, r0, LSL #1 ;r0乘以3
             LDMFD sp!,{pc}
             END
         
        下面的例子显示了如何用嵌入式汇编语言实现上面的例子。在此例中，使用 __cpp 关键字引用该函数。因此，用户不必了解已延伸的函数名。
         
        struct T {
             T(int i) : t(i) { }
             int t;
             int f(int i);
        };
        int T::f(int i) { return i + t; }
        // 定义被C++调用的汇编功能
        __asm int asm_func(T*) {
            STMFD sp!, {lr}
            MOV r1, #2;
            BL __cpp(T::f);
            ADD r0, r0, r0, LSL #1 ;r0乘以3
            LDMFD sp!, {pc}
        }
        int f() {
              T t(5); // 创建T类型的对象
              return asm_func(&t);
        }
        联系方