在嵌入式软件开发中，编译器优化等级通常有四个级别：O0、O1、O2、O3（有时还有Os）。这些优化等级在编译代码时会影响代码的执行效率、代码大小和调试难易度。

一、嵌入式软件开发编译优化的等级

1. O0（Level 0） - 不优化

意义：完全关闭优化，编译器只进行最基本的转换。这是默认的编译选项，不进行任何优化。编译器的目标是减少编译时间和确保调试信息与代码完全对应，便于调试。

作用：生成的代码与源代码的行号对应，变量都在内存中，方便设置断点和查看变量值。但代码执行效率最低，代码体积最大。

生成与源代码行号完全对应的机器码变量存储在内存而非寄存器中保留所有调试信息编译速度最快

适用场景：开发调试阶段。

int add(int a, int b) {    return a + b;}int main() {    int x = 5;    int y = 10;    int z = add(x, y);    return 0;}

在O0下，add函数会被完整编译，会有明确的调用和返回，变量x和y会被存储在栈上，调试时可以看到这些变量。

2.O1（Level 1）（基础优化）

意义：在保证编译速度的同时进行基本优化。编译器尝试减少代码体积和提高执行速度，但不会进行耗时较长的优化。

作用：编译器会进行一些简单的优化，比如删除未使用的变量和表达式，简化跳转等。调试信息可能不精确，但代码体积和速度有所改善。

删除未使用的变量和函数简化算术表达式优化跳转指令有限度的寄存器分配

适用场景：快速开发、需要一定性能的场景。

int add(int a, int b) {    return a + b;}int main() {    int x = 5;    int y = 10;    int z = add(x, y);    return 0;}

示例：对于上面的代码，O1可能会将add函数内联展开，但不会进行更复杂的优化。

3.O2（Level 2）（中级优化）

意义：广泛优化，平衡性能与代码大小。在O1的基础上进行更多优化，包括指令调度等，以提高代码执行速度，但可能会增加代码体积。

作用：编译器会尝试进行循环展开、函数内联、删除冗余代码等。调试会变得更困难，因为代码可能会被重排。

循环优化（展开、合并）函数内联（小函数）指令调度数据流分析

适用场景：发布版本，最常用。

示例：

int i;int sum = 0;for (i = 0; i < 100; i++) {    sum += i;}

在O2下，循环可能会被展开，例如每次迭代处理多个元素，或者直接计算出结果而不使用循环。

4.O3（Level 3）（高级优化）

意义：最大性能优化，可能增加代码大小。最高级别的优化，旨在最大程度地提高代码执行速度，可能会增加代码体积，并可能导致一些意想不到的结果（因为优化过于激进）。

作用：除了O2的优化外，还会进行更多激进优化，如函数内联、循环展开、向量化等。代码可能和源代码相差很大，难以调试。

更激进的函数内联循环向量化（SIMD）预测执行优化跨模块优化

适用场景：性能敏感型应用

示例：对于上面的循环，O3可能会使用SIMD指令进行向量化计算，同时进行更多的循环展开。

5. Os（优化代码大小）

意义：有时在嵌入式系统中，代码体积非常重要。Os优化等级会在O2的基础上，选择不会显著增加代码体积的优化选项，有时甚至会为了减小体积而降低速度。

作用：编译器会尝试减小代码体积，例如避免循环展开，选择更小的代码序列等。

注意：不同的编译器可能会有一些差异，但大体上这些优化等级的意义相似。

二、实际C语言示例分析

optimization_example.c

#include <stdint.h>// 简单数学运算函数int multiply_and_add(int a, int b, int c) {    return a * b + c;}// 带有循环的函数void process_array(uint8_t *dst, const uint8_t *src, int len) {    for (int i = 0; i < len; i++) {        dst[i] = src[i] * 2 + 1;    }}// 条件分支较多的函数int max_of_three(int x, int y, int z) {    if (x > y) {        if (x > z) {            return x;        } else {            return z;        }    } else {        if (y > z) {            return y;        } else {            return z;        }    }}// 小工具函数static inline int square(int x) {    return x * x;}int main(void) {    int result = 0;    // 测试数学运算    result += multiply_and_add(3, 4, 5);    // 测试数组处理    uint8_t src[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};    uint8_t dst[10];    process_array(dst, src, 10);    // 测试条件判断    result += max_of_three(10, 20, 15);    // 测试内联函数    result += square(7);    return result;}各优化等级具体表现

1.O0级别（无优化）

# multiply_and_add 函数在ARM Cortex-M上的O0编译multiply_and_add:    push    {r11, lr}      ; 保存寄存器    add     r11, sp, #4; 设置帧指针    sub     sp, sp, #16 ; 为局部变量分配空间    str     r0, [r11, #-8] ; a存储到内存    str     r1, [r11, #-12]; b存储到内存    str     r2, [r11, #-16]; c存储到内存    ldr     r3, [r11, #-8] ; 从内存加载a    ldr     r2, [r11, #-12]; 从内存加载b    mul     r3, r2, r3     ; a * b    ldr     r2, [r11, #-16]; 从内存加载c    add     r3, r3, r2     ; 结果+c    mov     r0, r3         ; 准备返回值    sub     sp, r11, #4; 恢复栈指针    pop     {r11, lr}      ; 恢复寄存器    bx      lr             ; 返回

特点：

所有变量存储在内存中每次使用都要加载/存储函数调用完全保留代码体积最大，执行最慢

2.O1级别优化

# multiply_and_add 函数的O1编译multiply_and_add:    mul     r0, r1, r0     ; a * b    add     r0, r0, r2     ; 结果+c    bx      lr             ; 直接返回

优化效果：

消除冗余的栈操作参数直接使用寄存器删除不必要的加载/存储代码大小减少约60%

3.O2级别优化

# process_array 循环的O2编译（伪代码表示）process_array:    cmp     r2, #0 ; 检查长度    ble     .L1            ; 长度<=0则跳转    mov     r3, #0 ; i = 0.L2:    ldrb    r12, [r1, r3]  ; 加载src[i]    add     r12, r12, r12  ; src[i] * 2    add     r12, r12, #1; +1    strb    r12, [r0, r3]  ; 存储到dst[i]    add     r3, r3, #1; i++    cmp     r3, r2         ; i < len?    bne     .L2            ; 继续循环.L1:    bx      lr

优化效果：

循环不变式计算外提强度削减（乘法变加法）更好的寄存器分配max_of_three函数可能被优化为条件移动指令

4.O3级别优化

# process_array 可能被向量化（如果平台支持）process_array:    ; 假设支持NEON的ARM处理器    ; 可能使用向量指令一次处理多个数据    vld1.u8 {d0}, [r1]!    ; 加载8个字节    vadd.u8 d0, d0, d0     ; 每个乘以2（加法实现）    vadd.u8 d0, d0, #1; 每个加1    vst1.u8 {d0}, [r0]!    ; 存储8个字节    ; ... 继续处理剩余数据

优化效果：

循环展开（可能展开2-4次）向量化指令使用square函数被内联展开跨函数优化可能消除冗余计算

5.特殊优化选项：Os

除了O0-O3，还有重要的Os优化（优化代码大小）。

意义：在O2的基础上，优先考虑代码体积而非执行速度

作用：

避免循环展开

选择代码更小的指令序列

减少函数内联

适用场景：Flash空间紧张的嵌入式系统

三、优化等级对比表

特性

O0

O1

O2

O3

编译速度

最快

快

中等

慢

代码大小

最大

中等

较小

可能增大

执行速度

最慢

中等

快

最快

调试友好

最好

好

较差

差

功耗优化

无

基础

较好

可能更好

内存使用

高

中等

较低

可能较高

嵌入式软件开发的编译器优化等级推荐：

1.开发阶段

(1) 调试阶段用O0（Level 0）；

(2) 性能测试使用O2（Level 2）；

2.发布版本选择

(1) 性能优先（有足够Flash），使用O3（Level 3）；

(2) 代码大小优先（Flash紧张），使用OS

(3) 平衡方案（最常用），使用O2（Level 2）

注意事项:

高优化等级可能改变程序时序，影响实时性优化可能暴露隐藏的代码缺陷（如未初始化变量）某些优化需要配合特定编译器选项关键代码可能需要volatile关键字防止过度优化

在嵌入式开发中，理解不同优化等级的影响对于平衡代码性能、大小和可调试性至关重要。通常建议从O0开始开发，在测试阶段尝试O2，根据最终产品的Flash/RAM限制和性能需求选择合适的优化等级。

本文内容来源于网络，仅供参考学习，如内容、图片有任何版权问题，请联系处理，24小时内删除。

作 者 | 郭志龙

编 辑 | 郭志龙校 对 | 郭志龙