Cortex-M汇编优化实战：从加减乘除到FIR滤波器的性能提升

1. 从C语言到汇编：为什么要在Cortex-M上手动写加减乘除？

很多刚开始接触Cortex-M处理器的朋友，尤其是从Arduino或者标准C语言开发转过来的，心里可能都有一个疑问：现在编译器这么强大，C语言写个a = b + c;既简单又安全，为什么还要费劲去学汇编，甚至手动去写加减乘除这种最基础的运算呢？这不是自找麻烦吗？

我刚开始也这么想，直到有一次，我在做一个电机控制项目，核心是一个高速PID闭环。用C语言写的循环，在72MHz的Cortex-M3上跑，定时器中断里计算时间总是差那么几微秒，导致控制环路出现抖动。用示波器抓波形，怎么优化C代码都无济于事。最后被逼无奈，我把最内层循环的几个关键计算——就是几个加法、乘法和移位——用手写汇编重写了一遍。你猜怎么着？整个中断服务程序的执行时间直接缩短了30%，控制波形瞬间平滑了。

那一刻我才真正明白，在Cortex-M这类资源受限的微控制器上，汇编不是用来炫技的，它是你最后的那把“手术刀”。当你需要：

1. 极致性能：编译器生成的代码虽然正确，但未必最优。对于循环、密集计算，手动汇编可以精确控制指令周期，消除冗余。
2. 精确时序：在通信协议模拟（如WS2812B的时序）、精准延时（纳秒级）场合，C语言的for循环或者DWT计数器都不够“硬核”，汇编能让你对每一个时钟周期了如指掌。
3. 理解底层：这是最重要的。你能看懂反汇编，知道你的int加法到底用的是ADD还是ADDW，知道编译器把i++优化成了什么，在调试内存越界、奇怪硬件故障时，这种洞察力是无价的。

所以，今天我们就抛开printf，深入Cortex-M的内心，看看它到底是如何执行我们习以为常的加减乘除的。这不是为了替代C，而是为了在关键时刻，你能拥有超越C的能力。

2. Cortex-M的算术指令集：你的武器库

在动手写代码之前，得先熟悉“武器”。Cortex-M系列处理器基于ARMv6-M（M0, M0+）、ARMv7-M（M3, M4）或ARMv8-M架构，其指令集是ARM Thumb/Thumb-2的精华子集。对于加减乘除，我们主要和以下几类指令打交道：

2.1 数据传输指令：战场上的搬运工

任何计算的前提，是把数据从内存（或外设）搬到寄存器（CPU的工作台），或者反过来。

• LDR(Load Register)： 从内存加载数据到寄存器。例如，LDR R0, [R1]将R1寄存器里的值作为内存地址，把该地址处的32位数据加载到R0。
• STR(Store Register)： 将寄存器里的数据存储到内存。例如，STR R0, [R1]将R0的值存储到R1指向的内存地址。
• MOV(Move)： 在寄存器之间，或者将一个小常数（立即数）移动到寄存器。这是最常用的指令之一。例如：
  • MOV R0, R1： 把R1的值复制到R0。
  • MOV R0, #0x55： 把常数0x55放到R0。

注意：MOV能移动的立即数范围是有限的（通常是一个8位常数循环右移偶数位得到）。对于像0x12345678这样的大数，通常需要用LDR R0, =0x12345678伪指令，编译器会帮你处理成合适的内存加载或复杂立即数构造序列。

2.2 核心算术指令：加减与移位

这是最基础、最快速的运算单元。

• ADD(Add)： 加法。格式：ADD Rd, Rn, Operand2。例如：
  • ADD R0, R1, R2： R0 = R1 + R2
  • ADD R0, R0, #1： R0 = R0 + 1 (相当于C语言的i++)
  • ADD R0, R1, R2, LSL #2： R0 = R1 + (R2 << 2) （这是一个复合操作，非常高效）
• ADC(Add with Carry)： 带进位加法。用于多精度（比如64位）加法。Rd = Rn + Operand2 + C Flag。
• SUB(Subtract)： 减法。Rd = Rn - Operand2。
• SBC(Subtract with Carry)： 带进位减法。用于多精度减法。Rd = Rn - Operand2 - !C Flag。注意这里是“借位”，所以用进位标志C的反。
• RSB(Reverse Subtract)： 反向减法。Rd = Operand2 - Rn。当你需要计算常数 - 变量时很有用。
• 移位指令： 虽然不直接算数，但和乘除息息相关。
  • LSL(Logical Shift Left)： 逻辑左移，低位补0。左移1位等于乘以2。
  • LSR(Logical Shift Right)： 逻辑右移，高位补0。右移1位等于无符号数除以2。
  • ASR(Arithmetic Shift Right)： 算术右移，高位用符号位填充。用于有符号数除以2的幂。

2.3 乘法指令：硬件加速的艺术

Cortex-M0/M0+的乘法器是选配的，如果有，指令是MULS。Cortex-M3/M4则拥有强大的单周期乘法器，指令更丰富。

• MUL(Multiply)： 32位乘法，产生结果的低32位。Rd = (Rn * Rm)[31:0]。这是最常用的。
• MLA(Multiply Accumulate)： 乘加。Rd = Ra + (Rn * Rm)。在数字信号处理（如FIR滤波器）中极为高效，一条指令完成乘和加。
• UMULL/UMLAL(Unsigned Multiply Long)： 无符号长乘法，产生64位结果。[RdHi, RdLo] = Rn * Rm。
• SMULL/SMLAL(Signed Multiply Long)： 有符号长乘法，产生64位结果。

2.4 除法指令：来之不易的硬件支持

这是关键点：Cortex-M0/M0+/M3没有硬件除法器！除法需要软件库实现，速度很慢（几十到上百个周期）。Cortex-M4/M7等更高性能的型号才集成了硬件除法器（UDIV/SDIV指令）。

• UDIV(Unsigned Divide)： 无符号除法。Rd = Rn / Rm。
• SDIV(Signed Divide)： 有符号除法。

如果你的芯片是M0/M3，在汇编里写/操作，编译器会链接一个庞大的软件除法函数，性能是灾难性的。所以，在无硬件除法的芯片上，汇编编程的一个核心技巧就是：避免除法，用移位和乘法近似。

3. 实战演练：用汇编实现基础运算函数

理论说再多，不如动手写一行。我们假设一个场景：在一个Cortex-M3（无硬件除法）的项目中，我们需要几个高度优化的计算函数，用于实时数据处理。我们将用内联汇编（Embedded Assembly）的方式在C文件中实现，这是最常见也最实用的做法。

3.1 环境准备与内联汇编语法

我们使用ARM GCC编译器。内联汇编的基本格式如下：

__asm__ volatile ( "汇编指令1\n\t" "汇编指令2\n\t" ... : 输出操作数列表 // 将汇编结果输出到C变量 : 输入操作数列表 // 将C变量输入给汇编 : 破坏寄存器列表 // 告诉编译器我们改动了哪些寄存器 );

• __asm__： 关键字，也可写作asm。
• volatile： 告诉编译器不要优化这段汇编，必须原样保留。
• \n\t： 确保每条指令在新的一行，并添加制表符，符合汇编器格式。
• 操作数约束： 例如"=r" (sum)表示输出一个寄存器到变量sum，"r" (a)表示把变量a的值放入一个寄存器作为输入。
• 破坏列表： 例如"r0", "r1", "cc"表示我们使用了r0, r1寄存器，并改变了条件标志（cc）。

3.2 加法与减法：简单背后的优化

我们先看一个“多此一举”的例子，但能说明原理：

// 函数：32位整数加法（汇编版） int32_t add_asm(int32_t a, int32_t b) { int32_t result; __asm__ volatile ( "ADD %[res], %[in_a], %[in_b]\n\t" // 核心加法指令 : [res] "=r" (result) // 输出：结果到result变量 : [in_a] "r" (a), [in_b] "r" (b) // 输入：a, b的值给寄存器 : // 无额外破坏 ); return result; }

这个函数和C写的return a + b;几乎没区别，编译器大概率会生成相同的指令。那意义何在？意义在于确定性和复合操作。

实战技巧：融合加载与运算在循环中，经常是“从数组取数，然后计算”。用C写是sum += array[i];，编译器会生成LDR然后ADD两条指令。但在汇编里，我们可以用更强大的寻址模式一条指令完成：

// 假设 R0 = sum, R1 = array基地址, R2 = i (索引) __asm__ volatile ( "LDR R3, [%[arr], %[idx], LSL #2]\n\t" // R3 = *(arr + i*4)。LSL #2是因为int是4字节 "ADD %[sum], %[sum], R3\n\t" // sum += R3 : [sum] "+r" (sum) // “+”表示该操作数既是输入又是输出 : [arr] "r" (array), [idx] "r" (i) : "r3", "cc" // 声明我们破坏了R3和条件标志 );

这里的关键是[R1, R2, LSL #2]这种“基址+变址+移位”的寻址模式，它在一个指令周期内完成了地址计算和内存读取，比分开操作高效得多。这是手动汇编优化中常见的手法。

3.3 乘法：利用乘加指令提升性能

假设我们要计算一个点积：sum = a1*b1 + a2*b2 + a3*b3。C语言写法清晰，但编译器可能会生成三条MUL指令和三条ADD指令。对于Cortex-M4（支持MLA），我们可以手动优化：

int32_t dot_product_asm(int32_t a1, int32_t b1, int32_t a2, int32_t b2, int32_t a3, int32_t b3) { int32_t sum; __asm__ volatile ( "MUL R0, %[a1], %[b1]\n\t" // R0 = a1 * b1 "MLA R0, %[a2], %[b2], R0\n\t" // R0 = a2 * b2 + R0 "MLA %[out], %[a3], %[b3], R0\n\t" // out = a3 * b3 + R0 : [out] "=r" (sum) : [a1] "r" (a1), [b1] "r" (b1), [a2] "r" (a2), [b2] "r" (b2), [a3] "r" (a3), [b3] "r" (b3) : "r0", "cc" ); return sum; }

这里MLA指令将乘法和加法合二为一，减少了指令数量和依赖，提升了流水线效率。在DSP类应用中，这种优化效果显著。

3.4 除法：在无硬件支持的M3上的生存之道

这是重头戏。在Cortex-M3上，一个32位除法可能需要上百个周期。我们必须想尽办法避免。

场景：我们需要在一个控制循环中计算error = (setpoint - feedback) / scaling_factor，其中scaling_factor可能变化，但通常是2的幂次（如1, 2, 4, 8...）或者一个固定的常数。

方案一：对于2的幂次除数，用移位代替这是最理想的情况。如果scaling_factor是2、4、8等，直接用ASR（有符号）或LSR（无符号）右移。

// 代替 error = (setpoint - feedback) / 8; int32_t error; __asm__ volatile ( "SUB R0, %[set], %[fb]\n\t" // R0 = setpoint - feedback "ASR %[err], R0, #3\n\t" // error = R0 >> 3 (即除以8) : [err] "=r" (error) : [set] "r" (setpoint), [fb] "r" (feedback) : "r0", "cc" );

方案二：对于非2的幂次的常数除数，用乘法近似这是核心技巧。原理是：x / C = x * (1/C)。但1/C是个小数，计算机用整数怎么办？我们用定点数（Fixed-Point）乘法来模拟。 例如，要计算x / 5。我们可以预先计算M = (1 << 32) / 5的整数近似值（即0.2的Q32定点数表示）。那么(x * M) >> 32就近似等于x / 5。

// 快速整数除法：计算 x / 5 (近似) #define INV_5_Q32 0xCCCCCCCD // (1<<32)/5 的十六进制近似值 int32_t divide_by_5_approx(int32_t x) { int64_t temp; // 需要64位中间变量防止溢出 int32_t result; __asm__ volatile ( "SMULL %[tmp_lo], %[tmp_hi], %[x], %[inv]\n\t" // [tmp_hi:tmp_lo] = x * INV_5_Q32 "MOV %[res], %[tmp_hi]\n\t" // 结果取高32位，相当于右移32位 : [res] "=r" (result), [tmp_lo] "=&r" (((int32_t*)&temp)[0]), [tmp_hi] "=&r" (((int32_t*)&temp)[1]) : [x] "r" (x), [inv] "r" ((int32_t)INV_5_Q32) : "cc" ); return result; }

注意：SMULL指令将两个32位有符号数相乘，产生64位结果，低32位在RdLo，高32位在RdHi。这里我们只取高32位，完成了(x * M) >> 32的操作。这种方法精度很高，对于大多数控制应用足够了，且速度比软件除法快一个数量级。

方案三：当除数完全未知且变化时如果除数是一个运行时变量（非常量），且不是2的幂次，在M3上我们几乎无法避免调用编译器提供的软件除法库（如__aeabi_idiv）。但在汇编中调用它，你需要遵循ARM的调用约定（AAPCS），这涉及到寄存器保存和恢复，比较复杂。通常的做法是，在C代码中直接使用/运算符，让链接器去处理。在汇编层面，更优的策略是重新审视你的算法，看能否通过代数变换消除这个运行时除法。

4. 进阶技巧与性能陷阱

掌握了基本运算的汇编实现，我们来看看如何将它们组合起来，并避开一些常见的坑。

4.1 条件执行与标志位：让代码更紧凑

ARM Thumb-2指令集的一个强大特性是大多数指令可以条件执行。这依赖于程序状态寄存器（PSR）中的条件标志位（N, Z, C, V）。加减运算会自动设置这些标志。

// C语言： if (a > b) max = a; else max = b; // 汇编实现，利用比较和条件选择 int32_t max_val; __asm__ volatile ( "CMP %[a], %[b]\n\t" // 比较a和b，设置标志位 "ITE GT\n\t" // If-Then-Else 块：如果 GT (Greater Than) 为真 "MOVGT %[max], %[a]\n\t" // 则 max = a "MOVLE %[max], %[b]\n\t" // 否则 max = b : [max] "=r" (max_val) : [a] "r" (a), [b] "r" (b) : "cc" );

ITE是IF-THEN-ELSE的汇编伪指令，它和后面的条件指令（MOVGT,MOVLE）配合，避免了使用分支跳转指令（BGT,BLE），而分支预测失败会清空流水线，带来巨大性能损失。在短小的判断中，使用条件执行指令能显著提升性能。

4.2 数据对齐与内存访问惩罚

Cortex-M处理器通常要求字（32位）访问是4字节对齐的，半字（16位）访问是2字节对齐的。非对齐访问在有些型号上会导致硬件错误（HardFault），在有些型号上则能执行但需要多个总线周期，造成性能损失。

// 错误的例子：可能导致非对齐访问或性能下降 uint32_t* ptr = (uint32_t*)((char*)buffer + 1); // 强制转换到一个非4字节对齐的地址 uint32_t val = *ptr; // LDR指令可能触发HardFault或变慢 // 在汇编中，确保你传递给LDR/STR的地址是对齐的。 // 对于从字节数组加载一个32位字，安全的做法是： uint8_t byte_array[10]; uint32_t word; __asm__ volatile ( "LDRB R0, [%[addr]]\n\t" // 加载第一个字节 "LDRB R1, [%[addr], #1]\n\t" // 加载第二个字节 "LDRB R2, [%[addr], #2]\n\t" // 加载第三个字节 "LDRB R3, [%[addr], #3]\n\t" // 加载第四个字节 "ORR %[w], R0, R1, LSL #8\n\t" // 组合成32位字 "ORR %[w], %[w], R2, LSL #16\n\t" "ORR %[w], %[w], R3, LSL #24\n\t" : [w] "=r" (word) : [addr] "r" (byte_array) : "r0", "r1", "r2", "r3", "cc" );

虽然这段汇编比一条未对齐的LDR指令长，但它是确定安全且可移植的。在性能敏感区域，数据结构的设计应保证关键数据是对齐的。

4.3 寄存器分配策略与编译器协作

内联汇编中，输入输出操作数的约束（如"r","=r","+r"）告诉编译器如何分配寄存器。但如果你在汇编块内部随意使用寄存器（比如R4-R11），而没在破坏列表里声明，程序可能会发生难以调试的崩溃，因为这些寄存器在ARM调用约定中是被调用者需要保存的（callee-saved）。

黄金法则：

1. 尽量使用“r”约束让编译器分配寄存器： 编译器比你更了解全局的寄存器使用情况。
2. 明确列出所有破坏的寄存器： 包括在指令中显式使用的（如R0,R1）以及隐式改变的（条件标志"cc", 内存"memory"）。
3. 对于中间结果寄存器，使用“=&r”约束： 等号=表示只写，&表示该操作数在指令执行完成前就会被使用（早期破坏操作数），防止编译器把它分配给输入操作数，造成数据覆盖。这在SMULL这种双输出指令中尤其重要（见前面除法例子中的[tmp_lo] "=&r"）。

4.4 调试与验证：如何确认你的汇编是对的？

写汇编很容易出错，一个标点符号不对就可能让系统跑飞。我的调试流程是：

1. 先写C版本： 实现完全相同的功能，并确保它是正确的。用一组测试数据验证。
2. 逐步替换： 不要一下子把所有计算都换成汇编。先替换一个最简单的加法函数，用C版本的结果做对比测试。
3. 使用调试器反汇编： 在Keil、IAR或VSCode+GDB中，单步调试进入你的汇编函数。查看反汇编窗口，确认生成的指令和你预想的一致。观察寄存器的变化。
4. 性能对比： 使用芯片的DWT（Data Watchpoint and Trace）周期计数器，或者一个高精度定时器，分别测量C版本和汇编版本函数的执行时间。只有看到可观的提升，你的优化才有意义。
5. 边界测试： 用最大值（0x7FFFFFFF）、最小值（0x80000000）、0、负数等边界值测试你的除法近似函数，评估其精度和溢出行为。

5. 从加减乘除到实际项目：一个简单的FIR滤波器实现

让我们把这些点串联起来，看一个稍微复杂点的例子：一个4阶FIR（有限脉冲响应）滤波器的汇编优化实现。这是嵌入式信号处理中非常常见的模块。

C语言参考实现：

// 滤波器系数和状态缓冲区 static int32_t coeffs[4] = {100, 200, 150, 50}; // Q15格式的系数 static int32_t state[4] = {0}; // 延迟线状态 int32_t fir_filter_c(int32_t input) { // 更新状态（滑动窗口） state[3] = state[2]; state[2] = state[1]; state[1] = state[0]; state[0] = input; // 计算卷积和 int64_t acc = 0; // 使用64位累加器防止溢出 for (int i = 0; i < 4; i++) { acc += (int64_t)state[i] * coeffs[i]; } // 假设系数是Q15格式，结果需要右移15位 return (int32_t)(acc >> 15); }

这个实现清晰，但循环和每次的64位乘法在M3上开销不小。

汇编优化版本： 我们的目标是：展开循环，使用MLA指令，并优化状态更新。

int32_t fir_filter_asm(int32_t input) { int32_t result; // 我们将state数组的地址和coeffs数组的地址作为输入 // 注意：此函数会修改state数组的内容（更新延迟线） __asm__ volatile ( // 1. 加载所有系数到寄存器（假设系数不变，可预先加载，这里为演示动态加载） "LDR R4, [%[coeff], #0]\n\t" // R4 = coeffs[0] "LDR R5, [%[coeff], #4]\n\t" // R5 = coeffs[1] "LDR R6, [%[coeff], #8]\n\t" // R6 = coeffs[2] "LDR R7, [%[coeff], #12]\n\t" // R7 = coeffs[3] // 2. 加载当前状态到寄存器 "LDR R0, [%[state], #0]\n\t" // R0 = state[0] (最新) "LDR R1, [%[state], #4]\n\t" // R1 = state[1] "LDR R2, [%[state], #8]\n\t" // R2 = state[2] "LDR R3, [%[state], #12]\n\t" // R3 = state[3] (最旧) // 3. 更新状态延迟线（为下一次采样准备） "STR %[in], [%[state], #0]\n\t" // state[0] = input (新样本) "STR R0, [%[state], #4]\n\t" // state[1] = 旧的state[0] "STR R1, [%[state], #8]\n\t" // state[2] = 旧的state[1] "STR R2, [%[state], #12]\n\t" // state[3] = 旧的state[2] // 旧的state[3] (R3) 被丢弃 // 4. 计算乘累加 (使用展开的MLA链) // 从最旧的样本开始乘加，有助于减少数据依赖，提高流水线效率 "MUL R8, R3, R7\n\t" // R8 = state[3] * coeff[3] "MLA R8, R2, R6, R8\n\t" // R8 += state[2] * coeff[2] "MLA R8, R1, R5, R8\n\t" // R8 += state[1] * coeff[1] "MLA R8, R0, R4, R8\n\t" // R8 += state[0] * coeff[0] // 现在 R8 是 Q30格式的结果（因为两个Q15数相乘得到Q30） // 5. 将结果从Q30格式转换回Q15（右移15位） // 简单处理：取高16位。更精确的做法是四舍五入。 "ASR %[out], R8, #15\n\t" // out = R8 >> 15 : [out] "=r" (result), [state] "+r" (state) // state既是输入（地址）也是输出（被修改） : [in] "r" (input), [coeff] "r" (coeffs) : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "cc", "memory" // 声明破坏了R0-R8，条件标志，以及memory（因为修改了state数组） ); return result; }

这段代码的优化点分析：

1. 循环展开： 将4次循环完全展开，消除了循环计数和分支跳转的开销。
2. 寄存器重用： 将系数和状态值一次性加载到寄存器（R4-R7, R0-R3），后续所有操作都在寄存器间进行，速度极快。
3. 高效的乘加： 使用MLA指令链，将4次乘法和3次加法融合成4条指令。
4. 流水线友好： 乘加链从最旧的样本开始，与前面的状态更新指令（STR）数据依赖较小，处理器可以更好地并行执行。
5. 明确的破坏列表： 列出了所有使用的寄存器，并声明了"memory"，因为函数修改了state数组，这确保了编译器不会在汇编块前后错误地缓存state的值。

这个汇编版本的FIR滤波器，相比朴素的C版本，在Cortex-M3上预计能获得2-3倍的性能提升，并且时序完全确定。这就是手动汇编在数字信号处理等实时性要求极高领域的价值所在。

最后，我必须强调，汇编优化是一把双刃剑。它带来了性能和可控性，但也牺牲了可读性、可移植性和开发效率。我的经验法则是：先用C写出清晰正确的代码，然后用性能分析工具（如Profiler）找到真正的热点（Hot Spot），最后只对这些热点函数进行谨慎的汇编优化，并且必须附上详细的注释和测试用例。记住，你写的每一行汇编，未来都可能需要你自己或你的同事来调试。让每一行汇编都有其不可替代的价值，这才是嵌入式高手应有的态度。