运用结构体优化Cortex-M0/M0+程序

青旅半醒 2022-05-31 06:52 146阅读 0赞

将全局变量组合成结构体，结构体成员变量的数目不超过32个，并按照大小排放，如此可以利用Cortex-M0/M0+的指令集生成最优的代码。

mingdu.zheng **at** gmail *dot* com  
[http://blog.csdn.net/zoomdy/article/details/79304324][http_blog.csdn.net_zoomdy_article_details_79304324]

## 将全局变量组合成结构体 ##

来看一段很简单的实例代码。

// 前半部分使用3个分散的全局变量，将他们初始化成0
    int a, b, c;
    void init1(void)
    {
        
        a = 0;
        b = 0;
        c = 0;
    }

// 后半部分使用结构体将他们组合，同样将他们初始化成0
    struct {
        
        int a;
        int b;
        int c;
    }t;
    
    void init2(void)
    {
        
        t.a = 0;
        t.b = 0;
        t.c = 0;
    }

转化成汇编

arm-none-eabi-gcc -S -O2 -Wall init.c

汇编输出如下

// 前半部分的汇编输出
    	.global	init1
    	.type	init1, %function
    init1:
    	ldr	r0, .L2    // 加载a变量的地址
    	ldr	r1, .L2+4  // 加载b变量的地址
    	ldr	r2, .L2+8  // 加载c变量的地址
    	mov	r3, #0
    	str	r3, [r0]   // 设置a变量为0
    	str	r3, [r1]   // 设置b变量为0
    	str	r3, [r2]   // 设置c变量为0
    	bx	lr
    .L3:
    	.align	2
    .L2:
    	.word	a          // 常量池存储a变量的地址
    	.word	b          // 常量池存储b变量的地址
    	.word	c          // 常量池存储c变量的地址

// 后半部分的汇编输出
    	.global	init2
    	.type	init2, %function
    init2:
    	ldr	r3, .L5       // 加载结构体首地址
    	mov	r2, #0
    	str	r2, [r3]      // 设置a变量为0
    	str	r2, [r3, #4]  // 设置b变量为0
    	str	r2, [r3, #8]  // 设置c变量为0
    	bx	lr
    .L6:
    	.align	2
    .L5:
    	.word	t             // 常量池存储结构体首地址

两部分的汇编输出对比一下，就很清楚使用结构体的好处了。

使用分散变量，会占用更多的常量池空间，每个全局变量的地址都要存储在常量池，而使用结构体只需要存储结构体首地址，这是因为全局变量存储在什么位置是由链接器决定的，虽然代码中这几个变量是挨着定义的，但是编译器不能假设他们在内存中也是挨着，而结构体作为一个整体，其成员变量一定是挨着的，所以只需要结构体首地址加偏移就可以了。

.word	a          // 常量池存储a变量的地址
    	.word	b          // 常量池存储b变量的地址
    	.word	c          // 常量池存储c变量的地址

.word	t          // 常量池存储结构体首地址

使用分散变量，会使用更多的指令，每个全局变量都需要单独加载其存储地址，上面的例子中使用了3个全局变量，就有3条LDR指令分别加载他们的地址，而使用了结构体只需要1条LDR指令加载结构体首地址。使用更多的指令意味着需要更多的代码空间以及执行时间。

ldr	r0, .L2    // 加载a变量的地址
    	ldr	r1, .L2+4  // 加载b变量的地址
    	ldr	r2, .L2+8  // 加载c变量的地址

ldr	r3, .L5    // 加载结构体首地址

总结一下，使用结构体组织分散的全局变量既可以节省存储空间，又可以获得更快的执行速度。

## 结构体的大小和排放次序 ##

Cortex-M0/M0+只有16位的LDR/STR指令，其指令形式如下：

LDR  <Rt>,[<Rn>, <Rm>]    // Rt = memory[Rn + Rm]
    STR  <Rt>,[<Rn>, <Rm>]    // memory[Rn + Rm] = Rt
    LDRH <Rt>,[<Rn>, <Rm>]    // Rt = memory[Rn + Rm]
    STRH <Rt>,[<Rn>, <Rm>]    // memory[Rn + Rm] = Rt
    LDRB <Rt>,[<Rn>, <Rm>]    // Rt = memory[Rn + Rm]
    STRB <Rt>,[<Rn>, <Rm>]    // memory[Rn + Rm] = Rt
    
    LDR  <Rt>,[<Rn>, #immed5] // Rt = memory[Rn + ZeroExtend (#immed5<<2)]
    STR  <Rt>,[<Rn>, #immed5] // memory[Rn + ZeroExtend(#immed5<<2)] = Rt
    LDRH <Rt>,[<Rn>, #immed5] // Rt = memory[Rn + ZeroExtend (#immed5<<1)]
    STRH <Rt>,[<Rn>, #immed5] // memory[Rn + ZeroExtend(#immed5<<1)] = Rt
    LDRB <Rt>,[<Rn>, #immed5] // Rt = memory[Rn + ZeroExtend (#immed5)]
    STRB <Rt>,[<Rn>, #immed5] // memory[Rn + ZeroExtend(#immed5)] = Rt

为了获得最好的效果，应该尽量生成 `LDR <Rt>,[<Rn>, #immed5]` 类型的指令，这种类型的指令直接将偏移地址编码进了指令，不需要额外的指令去处理偏移，倘若编译出 `LDR <Rt>,[<Rn>, <Rm>]` 类型的指令，还需要指令来修改Rm的值来修改偏移。

`LDR <Rt>,[<Rn>, #immed5]` 的指令只有5位的立即数作为偏移值，LDR/STR最多可以偏移31个字（0124字节偏移范围），LDRH/STRH最多可以偏移31个半字（062字节偏移范围），LDRB/STRB最多可以偏移31个字节（0~31字节偏移范围），由此可以得出应该将8位长的变量放在结构体的最前面，16位长的变量次之，32位长的变量放在最后。倘若结构的大小超过32字节，又将8位长的变量放后面，那么生成的就是 `LDRB <Rt>,[<Rn>, <Rm>]` 指令了，那结构体的优势就不明显了。

结构体的大小应尽量控制在只产生 `LDR <Rt>,[<Rn>, #immed5]` 类型的指令，不会产生 `LDR <Rt>,[<Rn>, <Rm>]` 为宜。纯32位成员变量不宜超过128字节，纯16位变量不宜超过64字节，纯8位变量不宜超过31字节。基本上 **结构体成员变量的数目不超过32个，并按照大小排放** ，可以做到最好的效果。

## 临时变量需要使用结构体吗？ ##

不需要，临时变量由编译器决定存储在寄存器或堆栈内。首先编译器会尽量让临时变量存储在寄存器，寄存器不够用的情况下存储在堆栈中，在堆栈中的偏移是编译器控制的，所以编译知道其偏移地址，会自动产生相应的最优指令。Cortex-M0/M0+用于访问堆栈内临时变量的指令如下：

LDR  <Rt>,[SP, #immed8]   // Rt = memory[SP + ZeroExtend(#immed8<<2)]
    STR  <Rt>,[SP, #immed8]   // memory[SP + ZeroExtend(#immed8<<2)] = Rt

只有字访问指令，没有半字或字节访问指令，Cortex-M的压栈是以字为单位的，即使程序定义的是半字或字节，压入堆栈的仍然是字。

这两条指令的立即数有8位，可以最多访问256个字。比常规的存储指令访问范围大得多。

[http_blog.csdn.net_zoomdy_article_details_79304324]: http://blog.csdn.net/zoomdy/article/details/79304324