21、宏与内联汇编：在宏中嵌入汇编代码，平台相关优化的宏封装，内联汇编的宏抽象

说到宏与内联汇编，我得先坦白一件事。早年我做嵌入式开发时，对汇编是又爱又怕。爱的是它能精准控制硬件，怕的是它让代码变得又丑又难移植。后来我发现，把内联汇编和宏结合起来，就像给一把锋利的刀配上了合适的刀鞘——既好用又安全。

说白了，宏封装内联汇编的目的就三个：隐藏平台差异、提升关键代码性能、保持C代码的可读性。你想想看，如果每次用个特殊指令都要写一堆 asm volatile，那代码得多难看？

为什么要在宏里嵌入汇编？

我遇到过不少项目，底层驱动里就那么几行汇编，却因为散落在各处，导致移植时改得想哭。宏封装的好处在于：

• 隔离平台差异：不同架构的汇编指令，通过宏统一接口
• 优化关键路径：中断开关、原子操作、寄存器读写，这些用汇编最直接
• 编译器屏障：volatile 和 memory clobber 在宏里统一处理，不容易漏

GCC 内联汇编基础回顾

在讲宏封装之前，得先复习一下 GCC 内联汇编的格式。嗯，这里我假设你已经见过它：

asm volatile ( 
    "指令序列" 
    : 输出操作数 
    : 输入操作数 
    : 被破坏的寄存器列表 
);

举个例子，ARM Cortex-M 上关中断的典型写法：

#define disable_interrupts() \
    do { \
        __asm__ volatile ("cpsid i" ::: "memory"); \
    } while(0)

#define enable_interrupts() \
    do { \
        __asm__ volatile ("cpsie i" ::: "memory"); \
    } while(0)

你看，这里用了 do-while(0) 包裹，确保宏展开后是一个完整的语句。memory clobber 告诉编译器内存可能被修改，防止乱序优化。这些都是我踩过坑之后才加上的。

平台相关优化的宏封装

不同处理器架构，同样的功能可能对应完全不同的指令。比如「读取当前程序计数器」：

架构	指令	宏封装
ARM	MOV R0, PC	#define GET_PC() ({ uint32_t pc; __asm__("mov %0, pc" : "=r"(pc)); pc; })
x86	MOV EAX, [ESP]	#define GET_PC() ({ uint32_t pc; __asm__("mov (%%esp), %0" : "=r"(pc)); pc; })
RISC-V	AUIPC rd, 0	#define GET_PC() ({ uint32_t pc; __asm__("auipc %0, 0" : "=r"(pc)); pc; })

我个人习惯的做法是：在头文件里用条件编译区分平台，上层代码统一调用宏。比如：

#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
    #define GET_PC() ({ uint32_t pc; __asm__("mov %0, pc" : "=r"(pc)); pc; })
#elif defined(__i386__) || defined(__x86_64__)
    #define GET_PC() ({ uint32_t pc; __asm__("mov (%%esp), %0" : "=r"(pc)); pc; })
#elif defined(__riscv)
    #define GET_PC() ({ uint32_t pc; __asm__("auipc %0, 0" : "=r"(pc)); pc; })
#else
    #error "Unsupported architecture for GET_PC()"
#endif

这样，业务代码里写 uint32_t addr = GET_PC(); 就行了，完全不用关心底层是什么架构。

内联汇编的宏抽象——从指令到语义

更高阶的用法，是把一组汇编指令封装成「语义宏」。比如 ARM 上的内存屏障：

#define dmb() \
    __asm__ volatile ("dmb" ::: "memory")

#define dsb() \
    __asm__ volatile ("dsb" ::: "memory")

#define isb() \
    __asm__ volatile ("isb" ::: "memory")

然后你可以组合它们，定义更高级的同步原语：

#define sync_complete() \
    do { \
        dmb(); \
        /* 这里可以插入其他操作 */ \
    } while(0)

#define sync_acquire() \
    do { \
        /* 先读数据，再读标志 */ \
        __asm__ volatile ("ldr %0, [%1]" : "=r"(val) : "r"(ptr)); \
        dmb(); \
    } while(0)

我曾经在一个多核项目中，因为漏掉了一个 dmb 屏障，导致两个核之间共享数据出现了不一致。查了两天才定位到问题。从那以后，我把所有内存屏障都封装成宏，并且在代码审查时重点检查。

避坑指南：宏内联汇编的常见陷阱

1. 忘记 volatile：编译器可能认为你的汇编「没有副作用」而优化掉。尤其是那些只修改状态寄存器、不产生输出的指令。
2. clobber 列表不完整：如果汇编指令修改了某个寄存器但没有声明，编译器可能用那个寄存器存放其他变量，导致数据被破坏。
3. 操作数约束错误：比如 ARM 上有些指令只能用特定的寄存器（如 R0-R3），约束写不对，编译出来的代码就是错的。
4. 宏参数展开问题：如果宏参数是表达式，直接嵌入汇编字符串里可能出问题。比如 "add %0, %1, %2" 中的 %2 如果传进来的是 a + b，汇编器会报错。

怎么解决第四个问题？我的做法是：先把参数赋值给局部变量，再用局部变量参与汇编：

#define ADD_WITH_CARRY(a, b, carry_in, result, carry_out) \
    do { \
        uint32_t _a = (a); \
        uint32_t _b = (b); \
        uint32_t _ci = (carry_in); \
        uint32_t _co; \
        __asm__ volatile ( \
            "adds %0, %1, %2\n\t" \
            "adc %3, %4, #0" \
            : "=r"(result), "=r"(_co) \
            : "r"(_a), "r"(_b), "r"(_ci) \
            : "cc" \
        ); \
        (carry_out) = _co; \
    } while(0)

你看，先把 a、b、carry_in 存到局部变量里，这样不管外面传什么表达式，都不会影响汇编字符串的解析。

SVG：宏封装内联汇编的知识体系

下面这张图，是我自己总结的宏封装内联汇编的完整知识结构。你可以把它当作一个检查清单：

实战：一个完整的宏封装示例

最后，给你看一个我实际项目中用过的例子——ARM Cortex-M 上的临界区保护。它把关中断、开中断和保存恢复状态都封装在宏里：

#define ENTER_CRITICAL() \
    do { \
        uint32_t _primask; \
        __asm__ volatile ( \
            "mrs %0, primask\n\t" \
            "cpsid i" \
            : "=r"(_primask) \
            : \
            : "memory" \
        ); \
        do { /* 这里放临界区代码 */ } while(0); \
        __asm__ volatile ( \
            "msr primask, %0" \
            : \
            : "r"(_primask) \
            : "memory" \
        ); \
    } while(0)

当然，实际使用时我不会把临界区代码塞在宏里。更好的做法是拆成两个宏：

#define CRITICAL_ENTER() \
    ({ uint32_t _primask; \
       __asm__ volatile ("mrs %0, primask\n\t cpsid i" : "=r"(_primask) :: "memory"); \
       _primask; })

#define CRITICAL_EXIT(primask) \
    __asm__ volatile ("msr primask, %0" :: "r"(primask) : "memory")

调用的时候：

uint32_t saved = CRITICAL_ENTER();
// ... 临界区操作 ...
CRITICAL_EXIT(saved);

这样既保留了灵活性，又把汇编细节藏得干干净净。嗯，这就是我理解的「宏封装内联汇编」的精髓——用宏的抽象能力，把底层指令变成高层语义，让代码既高效又优雅。

---

公众号:蓝海资料掘金营，微信deep3321