一、概述

在嵌入式系统开发中，C语言调用汇编语言是常见的需求，主要应用于：

• 直接访问硬件寄存器
• 实现高性能算法
• 执行特殊CPU指令
• 处理中断服务例程
• 实现系统底层功能

二、三种调用方式详解

1、内联汇编（Inline Assembly）

定义：内联汇编允许在C语言代码中直接嵌入汇编指令。这种方式通常用于在C函数中插入少量汇编指令，以执行特定操作（如操作特殊寄存器、使用特殊指令等）。

特点：

• 无需额外的函数调用开销
• 可直接访问C语言变量
• 编译器负责寄存器分配
• 语法依赖特定编译器

深入理解：

内联汇编语法依赖于编译器，不同编译器有不同语法（如GCC和MSVC不同）。

在GCC中，内联汇编由汇编指令、输出操作数、输入操作数和可能破坏的寄存器列表组成。

内联汇编使得汇编代码和C代码混合在一起，编译器负责处理寄存器分配和指令调度，但程序员需要确保指令正确性。

GCC/Clang语法示例：

#include <stdio.h>

int main() {
    int a = 10, b = 20, result;
    
    // 基本内联汇编
    __asm__ volatile (
        "add %0, %1, %2"  // 汇编指令
        : "=r" (result)   // 输出操作数
        : "r" (a), "r" (b) // 输入操作数
    );
    
    // 扩展内联汇编（更复杂的约束）
    int x = 5, y = 3;
    __asm__ volatile (
        "mov r0, %[x_val]\n\t"
        "mov r1, %[y_val]\n\t"
        "mul %[result], r0, r1"
        : [result] "=r" (result)
        : [x_val] "r" (x), [y_val] "r" (y)
        : "r0", "r1", "memory"  // 破坏列表
    );
    
    return 0;
}

ARM架构专用示例：

// 读取CPSR寄存器
uint32_t read_cpsr(void) {
    uint32_t cpsr;
    __asm__ volatile (
        "mrs %0, cpsr"
        : "=r" (cpsr)
    );
    return cpsr;
}

// 使能/禁用中断
void enable_interrupts(void) {
    __asm__ volatile ("cpsie i");
}

void disable_interrupts(void) {
    __asm__ volatile ("cpsid i");
}

优缺点：

• 优点：无调用开销、灵活、可直接与C变量交互
• 缺点：可移植性差、调试困难、容易出错

2、独立的汇编函数

定义：编写独立的汇编源文件，在C中声明为外部函数。

调用流程：

C代码（main.c） → 声明extern函数 → 编译器 → 链接器 → 可执行文件
                             ↓
汇编代码（func.s） → 汇编器 → 目标文件

深入理解：

汇编函数需要遵循目标平台的调用约定（calling convention），包括参数传递、返回值、寄存器保存等。例如，在ARM架构中，前几个参数通常通过寄存器r0、r1等传递，返回值通过r0返回。

汇编函数通过.global（或.globl）指令导出符号，以便C代码链接。

独立的汇编文件可以使用完整的汇编语法，并且可以使用汇编器提供的所有功能。

示例结构：

C代码（main.c）：

#include <stdio.h>

// 声明外部汇编函数
extern int assembly_add(int a, int b);
extern void assembly_delay(uint32_t cycles);
extern uint32_t assembly_get_sp(void);

int main(void) {
    int result = assembly_add(10, 20);
    printf("Result: %d\n", result);
    
    assembly_delay(1000);
    
    uint32_t sp_value = assembly_get_sp();
    printf("Stack Pointer: 0x%08X\n", sp_value);
    
    return 0;
}

ARM汇编（arm_functions.s）：

.section .text
    .global assembly_add
    .global assembly_delay
    .global assembly_get_sp
    .syntax unified
    .thumb

/* 函数: assembly_add
 * 参数: R0 = a, R1 = b
 * 返回: R0 = a + b
 */
assembly_add:
    add r0, r0, r1
    bx lr

/* 函数: assembly_delay
 * 参数: R0 = 循环次数
 */
assembly_delay:
    subs r0, r0, #1
    bne assembly_delay
    bx lr

/* 函数: assembly_get_sp
 * 返回: R0 = 当前栈指针
 */
assembly_get_sp:
    mov r0, sp
    bx lr

编译链接：

# 分别编译
arm-none-eabi-gcc -c main.c -o main.o
arm-none-eabi-as arm_functions.s -o arm_functions.o

# 链接
arm-none-eabi-gcc main.o arm_functions.o -o program.elf

调用约定（ARM AAPCS）：

用途	寄存器	说明
参数1-4	R0-R3	前4个整数参数
参数5+	栈	剩余参数通过栈传递
返回值	R0	整数/指针返回值
链接寄存器	LR(R14)	返回地址
栈指针	SP(R13)	必须8字节对齐

优缺点：

• 优点：代码分离、可维护、可复用、调用规范清晰
• 缺点：有调用开销、需要处理ABI细节

3、函数指针调用

定义：这种方式将汇编代码放置在内存的某个位置，然后通过函数指针来调用。这种方式通常用于动态生成的代码，或者在没有操作系统的情况下直接跳转到指定地址执行。

应用场景：

• 动态代码加载
• 固件升级
• 引导加载程序
• 动态钩子/拦截

深入理解：

这种方式通常用于低级编程，如引导加载程序、操作系统内核或动态代码生成。

需要确保目标地址的代码符合C函数的调用约定，否则可能导致程序崩溃。

在嵌入式系统中，可能需要将代码放置在特定的内存区域（如内部SRAM），并确保该区域可执行。

示例：

#include <stdint.h>

// 1. 定义函数指针类型
typedef int (*asm_func_t)(int, int);
typedef void (*delay_func_t)(uint32_t);

// 2. 汇编代码的机器码（示例：Thumb2指令）
// 对于 add r0, r0, r1; bx lr
const uint16_t add_code[] = {
    0x4408,  // ADD R0, R1 (Thumb: 0100 0100 0000 1000)
    0x4770   // BX LR    (Thumb: 0100 0111 0111 0000)
};

// 延迟循环的机器码
const uint16_t delay_code[] = {
    0x3801,  // SUBS R0, #1
    0xD1FD,  // BNE -2 (循环)
    0x4770   // BX LR
};

int main(void) {
    // 3. 设置代码在可执行区域（注意对齐和权限）
    // 实际项目中可能需要配置MPU/MMU
    volatile uint16_t *code_mem = (uint16_t*)0x20001000;
    
    // 4. 复制代码到可执行内存
    for(int i = 0; i < sizeof(add_code)/sizeof(add_code[0]); i++) {
        code_mem[i] = add_code[i];
    }
    
    // 5. 创建函数指针
    asm_func_t add_func = (asm_func_t)((uint32_t)code_mem | 0x1); // Thumb模式需要最低位为1
    
    // 6. 调用汇编函数
    int result = add_func(10, 20);
    
    // 清理指令缓存（如果需要）
    __asm__ volatile (
        "dsb sy\n\t"
        "isb sy"
    );
    
    return 0;
}

内存布局考虑：

// 在链接脚本中定义可执行区域
MEMORY {
    FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 512K
    SRAM (rwx) : ORIGIN = 0x20000000, LENGTH = 128K
    CODEGEN (rwx) : ORIGIN = 0x20001000, LENGTH = 4K  // 动态代码区域
}

缓存和内存屏障：

void execute_dynamic_code(void *code_addr, size_t size) {
    // 1. 确保代码写入完成
    __asm__ volatile("dsb sy");
    
    // 2. 无效化指令缓存
    __asm__ volatile("isb sy");
    
    // 3. 对于支持缓存的操作
    #ifdef CACHE_ENABLED
    SCB_CleanInvalidateDCache_by_Addr(code_addr, size);
    SCB_InvalidateICache();
    #endif
}

优缺点：

• 优点：高度灵活、支持动态代码
• 缺点：安全性风险、复杂的内存管理、需要缓存一致性处理

三、比较与选择

特性	内联汇编	独立汇编函数	函数指针调用
性能	最高（无调用开销）	中等（有调用开销）	中等/高（取决于实现）
可维护性	低	高	中等
可移植性	低（编译器依赖）	高	中等
调试难度	高	低	高
代码复用	低	高	中等
安全性	高	高	低（需额外保护）
使用场景	小段关键代码	完整功能模块	动态/插件系统

四、实际应用建议

1、何时使用哪种方式

使用内联汇编：

• 单条或几条指令
• 需要直接操作特定寄存器
• 性能关键路径
• 实现编译器不支持的指令

// 示例：内存屏障操作
static inline void memory_barrier(void) {
    __asm__ volatile("dmb sy" ::: "memory");
}

使用独立汇编函数：

• 完整的功能模块
• 中断服务例程
• 上下文切换
• 启动代码

/* 启动代码 - startup.s */
Reset_Handler:
    ldr sp, =_estack
    bl SystemInit
    bl main
    b .

使用函数指针调用：

• 引导加载程序
• 固件更新机制
• 虚拟机/解释器
• 安全监控/调试

2、最佳实践

1、遵循ABI规范

// 正确：遵循寄存器使用规范
extern int asm_func(int a, int b, int c, int d, int e);
// 前4个参数在R0-R3，第5个在栈上

2、保存恢复寄存器

my_function:
    push {r4-r8, lr}    ; 保存调用者保存的寄存器
    ; 函数体
    pop {r4-r8, pc}     ; 恢复并返回

3、处理栈对齐

aligned_function:
    push {r7, lr}
    sub sp, sp, #8      ; 确保8字节对齐
    ; 函数体
    add sp, sp, #8
    pop {r7, pc}

4、使用正确的指令集

.thumb                  ; 指定Thumb模式
.thumb_func             ; 标记为Thumb函数
my_thumb_function:
    ; Thumb指令

五、调试技巧

1、混合调试

# GDB调试混合代码
arm-none-eabi-gdb program.elf
(gdb) layout split        # 同时查看C和汇编
(gdb) stepi               # 单步执行汇编指令
(gdb) disassemble         # 显示反汇编

2、查看寄存器

// 在调试时检查寄存器值
void debug_registers(void) {
    uint32_t regs[16];
    __asm__ volatile (
        "stmia %0, {r0-r15}"
        : 
        : "r" (regs)
        : "memory"
    );
}

3、性能分析

// 使用CPU周期计数器
uint32_t start_cycle, end_cycle;

start_cycle = DWT->CYCCNT;
asm_function();
end_cycle = DWT->CYCCNT;

printf("Cycles: %u\n", end_cycle - start_cycle);

六、总结

在嵌入式系统中，C调用汇编的三种方式各有适用场景：

内联汇编适合小段高性能代码

独立汇编函数适合模块化、可复用的功能

函数指针调用适合动态、灵活的运行时系统

选择时需考虑性能需求、可维护性、可移植性和安全性要求。无论哪种方式，都需要深入理解目标架构的ABI、寄存器使用约定和内存模型，才能编写出正确、高效、可靠的嵌入式代码。