title: 链接脚本与重定位
tags: ARM
date: 2018-10-12 19:25:53
链接脚本与重定位
学习视频 韦东山
总结
- 尽量使用一体式的链接脚本，方便简单，灵活
- 学会使用链接脚本的值
- bss段和comm段是需要我们手动去清除的
- 位置无关码相关:
- 局部数组是位置无关的，但是其数组的初始值在链接地址中，所以over
- 不能使用全局变量和局部变量
- 跳转使用bl
- 重定位代码的第一次跳转需要使用
ldr才能跳出去 - 重定位之前，只能使用相对地址，使用bl跳转
链接脚本格式
SECTIONS {
...
secname start BLOCK(align) (NOLOAD) : AT ( ldadr )
{ contents } >region :phdr =fill
...
}
- secname, contents是必须的，其他可选
- secname：段名，用以命名此段。
- contents：决定哪些内容放在本段，可以是整个目标文件(.o)，也可以是目标文件中的某段（代码段、数据段等）。
start.o或者这样start.o *(.text) - start：是段的重定位地址，即本段运行的地址。如果代码中有位置无关指令，程序运行时这个段必须放在这个地址上。start可以用任意一种描述地址的符号来描述。
- BLOCK(align) 指定块对齐。比如，前一个段从0x30000000到0x300003F1，此处标记ALIGN(4)，表示此处最小占用4Bytes，即使下一个段是紧挨这个段，那么下一个段的起始地址（也就是运行地址）为0x300003F4。
- NOLOAD：告诉加载器程序运行时不加载该段到内存。
- AT(ldadr)：定义本段存储的地址，如果不使用这个选项，则加载地址等于运行地址，通过这个选项可以控制各段分别保存于输出文件中不同的位置。
注意 一般需要4字节对齐，如果代码段和数据段的重定位使用4字节读写
最简单的链接脚本
SECTIONS {
. = 0x33f80000;
.text : { *(.text) }
. = ALIGN(4);
.rodata : {*(.rodata*)}
. = ALIGN(4);
.data : { *(.data) }
. = ALIGN(4);
__bss_start = .;
.bss : { *(.bss) *(COMMON) }
__bss_end = .;
}
COMM段BSS段
对于全局变量来说，如果初始化了不为0的值，那么该全局变量则被保存在data段，如果初始化的值为0，那么将其保存在bss段，如果没有初始化，则将其保存在common段，等到链接时再将其放入到BSS段。关于第三点不同编译器行为会不同，有的编译器会把没有初始化的全局变量直接放到BSS段。
elf和bin文件
elf文件
1 链接得到elf文件，含有地址信息(load addr)
2 使用加载器(裸机程序是JTAG/应用程序的加载器本身也是个App去加载)
3 运行程序
4 如果loadaddr != runtimeaddr程序本身要重定位
核心程序运行时应该位于 runtimeaddr（reloate addr）或者链接地址
bin文件
1 elf生成bin文件
2 硬件机制启动，此时没有加载器
3 如果bin文件所在位置 不等于runtimeaddr ，程序本身实现重定位
bin文件/elf文件都不保存bss段 这些都是初始值为0 或者没有初始化的全局变量，程序运行时把bss段对应的空间清零
获得链接脚本的值
https://sourceware.org/ml/binutils/2007-07/msg00154.html 链接脚本的符号表
-
使用伪汇编指令
ldr r1, =__bss_start -
存放到一块区域,再去读取
.global _bss_start _bss_start: .word __bss_start ldr r1, _bss_start //读取内存,这里是读取label所在内存的数据 //c中这么引用lable extern ulong _bss_start; -
C中获取链接脚本的值,链接的时候会根据lds与C所需要的lds中的值,产生一张内存表,内存表的标号也就是lds中的符号名(__bss_start).===这里是重点
extern int __bss_start; int val =&__bss_start; //!< 获得__bss_start的值 int *p=&__bss_start; //!< p指向这个内存单元 ------------------------------------------------------------------ 下面是一个一个的符号表 ，都是 name + 地址的格式 ----- name: g_i //!<正常变量,存的是变量的地址 Addr:xxx ----- name: g_j Addr:xxx ------ name:__bss_start //!< lds中,存的就是值了 Addr:xxx ------
常规变量比如我们定义了
int g_i,那么就有一个int大小的内存分配出来,地址也就是&g_i,对于lds中的变量,我们也就要是需要先取址,再取值,也就是*(&__bss_start)- 对于变量与lds中的变量,C都是先建立一个符号表,符号表正常情况存档地址
- 因为在C的符号表中,正常变量
g_i的操作是:1.寻找符号表中的g_i,获得其内存地址,然后对内存操作 - 而Lds中的变量,实际上并没有对应的内存单元,符号表中的
__bss_start他的值(地址值)就是所需要的值.
总结:
- 对于常规变量g_i，得到里面的值，使用&g_i得到addr；
- 为了保持代码的一致，对于lds中的a1，使用&a1得到里面的值;
- 借助symbol table保存lds的变量，使用时加上"&"得到它的值，链接脚本的变量要在C程序中声明为外部变量，任何类型都可以；
重定位
全局变量
全局变量在放在链接地址指定的位置，所以其链接地址必须是可写的.
局部变量
虽然局部变量是在栈中的，但是局部变量的数组他的初始值是从链接地址中取出来的.例如:
参考 JTAG调试中nand调试章节
void memsetup()
{
unsigned long const mem_cfg_val[]={ 0x22011110, //BWSCON
0x00000700, //BANKCON0
0x00000700, //BANKCON1
0x00000700, //BANKCON2
0x00000700, //BANKCON3
0x00000700, //BANKCON4
0x00000700, //BANKCON5
0x00018005, //BANKCON6
0x00018005, //BANKCON7
0x008C07A3, //REFRESH
0x000000B1, //BANKSIZE
0x00000030, //MRSRB6
0x00000030, //MRSRB7
};
}
//mem_cfg_val是在栈，是位置无关的，但是他的初始值是去在链接地址取的，也就是0x3000000后面
// ip=300005bc
30000050: e1a0400c mov r4, ip
30000054: e8b4000f ldmia r4!, {r0, r1, r2, r3}
//从r4中指向的内存给r0~r3
//也就是说从 300005bc读取一些数据，但是这个时候300005bc（sdram）并没有被初始化且进行代码搬运，所以这里的数据肯定有问题
//这里的其实就是那个局部数组的值 mem_cfg_val
300005bc <.rodata>:
300005bc: 22011110 andcs r1, r1, #4 ; 0x4
300005c0: 00000700 andeq r0, r0, r0, lsl #14
300005c4: 00000700 andeq r0, r0, r0, lsl #14
300005c8: 00000700 andeq r0, r0, r0, lsl #14
300005cc: 00000700 andeq r0, r0, r0, lsl #14
300005d0: 00000700 andeq r0, r0, r0, lsl #14
300005d4: 00000700 andeq r0, r0, r0, lsl #14
300005d8: 00018005 andeq r8, r1, r5
300005dc: 00018005 andeq r8, r1, r5
300005e0: 008c07a3 addeq r0, ip, r3, lsr #15
300005e4: 000000b1 streqh r0, [r0], -r1
300005e8: 00000030 andeq r0, r0, r0, lsr r0
300005ec: 00000030 andeq r0, r0, r0, lsr r0
Disassembly of section .comment:
1-直接指定数据段位置（代码黑洞）
arm-linux-ld -Ttext 0 -Tdata 0x30000000
// 数据段如下
Disassembly of section .data:
30000000 <__data_start>:
30000000: Address 0x30000000 is out of bounds.
这个时候会发现，代码段从0开始，数据段从0x3000,0000开始，bin文件生成有0x3000,0000+1大小(1个全局变量)，也就是产生了代码黑洞.代码段和数据段有大量的空白.
在1中会产生巨大的代码空白，所以需要解决这个问题，也就是数据段和代码段不能有大的空白，必须紧靠着.
2-分散加载（数据段）
引入（手动确认数据段大小）
-
将数据段与代码段在一起，全部烧写到Nor的0地址上
-
运行时将全局变量复制到sdram上，做数据段的重定位
-
这里的Makefile需要使用链接脚本了,这里的关键就是实现了数据放置在A，但是实际运行的时候是在B
arm-linux-ld -T sdram.lds start.o led.o uart.o init.o main.o -o sdram.elf // 重点 data 0x30000000 : AT(0x700) { *(.data) } //放在0x700,但运行时在0x3000000 //lds SECTIONS { .text 0 : { *(.text) }//所有文件的.text .rodata : { *(.rodata) } //只读数据段 .data 0x30000000 : AT(0x800) { *(.data) } //放在0x700,但运行时在0x3000000 .bss : { *(.bss) *(.COMMON) }//所有文件的bss段，所有文件的.COMMON段 } -
需要手动初始化全局变量的值，也就是说先提前复制存储地址的值到运行地址，也就是将0x800的值复制0x3000,0000
// c语言调用全局变量 char g_Char = 'A'; putchar(g_Char); // 汇编，从484获取到链接的地址，也就是说从这个地方0x3000,0000取数据 450: e59f302c ldr r3, [pc, #44] ; 484 <.text+0x484> 454: e5d33000 ldrb r3, [r3] 458: e1a00003 mov r0, r3 45c: ebffff6f bl 220 <putchar> ... 484: 30000000 andcc r0, r0, r0手动复制数据段,注意需要先初始化sdram
/* 重定位data段 */ mov r1, #0x800 ldr r0, [r1] //读取0x800 的内容到r0 mov r1, #0x30000000 str r0, [r1] //将r0存到0x3000,0000
自动确认数据段大小
上述方式是看了反汇编，知道代码就一个全局变量，这在具体应用肯定是不行的，需要从链接脚本获得数据段的大小.修改链接脚本如下，其中可以通过data_load_addr获得其存储地址
SECTIONS {
.text 0 : { *(.text) }
.rodata : { *(.rodata) }
.data 0x30000000 : AT(0x700)
{
data_load_addr = LOADADDR(.data);
data_start = . ;//等于当前位置
*(.data) //等于数据段的大小
data_end = . ;//等于当前位置
}
.bss : { *(.bss) *(.COMMON) }
}
代码中自动复制相关的重定位的数据段
bl sdram_init
/* 重定位data段 */
ldr r1, =data_load_addr /* data段在bin文件中的地址, 加载地址 */
ldr r2, =data_start /* data段在重定位地址, 运行时的地址 */
ldr r3, =data_end /* data段结束地址 */
cpy:
ldrb r4, [r1] //从r1读到r4 读取一个字节，读取存储地址的值
strb r4, [r2] //r4存放到r2 写入到运行地址
add r1, r1, #1 //r1+1 存储地址++
add r2, r2, #1 //r2+1 运行地址++
cmp r2, r3 //r2 r3比较
bne cpy //如果不等则继续拷贝
bl main
3-全局重定位（一体式）
分散加载和全局重定位的对比
- 分体式链接脚本适合单片机，单片机自带有flash，不需要再将代码复制到内存占用空间。而我们的嵌入式系统内存非常大，没必要节省这点空间，并且有些嵌入式系统没有Nor Flash等可以直接运行代码的Flash，就需要从Nand Flash或者SD卡复制整个代码到内存；
- JTAG等调试器一般只支持一体式链接脚本；
代码段和数据段重定位，所以必须确保重定位前的代码必须是位置无关码.具体步骤如下
- 让文件直接从0x30000000开始，全局变量在0x3......；
- 烧写Nor Flash上 0地址处；
- 运行会把整个代码段数据段(整个程序)从0地址复制到SDRAM的0x30000000(重定位)；
- 修改链接脚本如下:
SECTIONS
{
. = 0x30000000;
. = ALIGN(4);
.text :
{
*(.text)
}
. = ALIGN(4);
.rodata : { *(.rodata) }
. = ALIGN(4);
.data : { *(.data) }
. = ALIGN(4);
__bss_start = .;
.bss : { *(.bss) *(.COMMON) }
_end = .;
}
代码搬运和清除bss如下
/* 重定位text, rodata, data段整个程序 */
mov r1, #0
ldr r2, =_start /* 第1条指令运行时的地址 */
ldr r3, =__bss_start /* bss段的起始地址 */
cpy:
ldr r4, [r1]
str r4, [r2]
add r1, r1, #4
add r2, r2, #4
cmp r2, r3
ble cpy
/* 清除BSS段 */
ldr r1, =__bss_start
ldr r2, =_end
mov r3, #0
clean:
str r3, [r1]
add r1, r1, #4
cmp r1, r2
ble clean
//bl main //这里代码还是在nor上的，为什么能运行？因为代码在nor其实也没有什么关系
ldr pc, =main/*绝对跳转，跳到SDRAM*/
halt:
b halt
BL跳转指令
在反汇编中的B或者Bl跳转指令，其并不是跳转的相应的地址
3000005c: eb000106 bl 30000478 <sdram_init>
30000060: e3a01000 mov r1, #0 ; 0x0
30000064: e59f204c ldr r2, [pc, #76] ; 300000b8 <.text+0xb8>
30000068: e59f304c ldr r3, [pc, #76] ; 300000bc <.text+0xbc>
当我们修改链接脚本的时候，修改了链接地址，机器码也是不变的.实际上的跳转其实是相对pc跳转.由链接器决定.
假设程序从0x30000000执行，当前指令地址：0x3000005c ,那么就是跳到0x30000478；如果程序从0运行，当前指令地址:0x5c 调到：0x00000478
跳转到某个地址并不是由bl指令所决定，而是由当前pc值决定。反汇编显示这个值只是为了方便读代码。
重点： 反汇编文件里， B或BL 某个值，只是起到方便查看的作用，并不是真的跳转。
bss段处理
汇编处理
初始值为0的全局变量是存放在bss段的，需要自己写代码清0
SECTIONS {
.text 0 : { *(.text) }
.rodata : { *(.rodata) }
.data 0x30000000 : AT(0x700)
{
data_load_addr = LOADADDR(.data);
data_start = . ;
*(.data)
data_end = . ;
}
bss_start = .; //bss开始地址是当前位置
.bss : { *(.bss) *(.COMMON) }
bss_end = .; //bss结束地址也是当前位置
}
代码如下:
/* 清除BSS段 */
ldr r1, =bss_start
ldr r2, =bss_end
mov r3, #0
clean:
strb r3, [r1]
add r1, r1, #1
cmp r1, r2
bne clean
bl main //这里代码还是在nor上的，为什么能运行？因为代码在nor其实也没有什么关系
halt:
b halt
上述代码是字节读写的，cpu是32位的，sdram是32位宽的，可以直接使用32位访问，这里需要对链接脚本进行4字节对齐,否则在clean清bss段的时候，bss的起始地址不是4字节对齐的，那么他向4取整，也就是
ldr r1, =bss_start 这里地址如果不是4取整，那么比如0x3000,0002
clean:
strb r3, [r1] //这里是将0 写入 0x3000,0002 ，但是这是str会向4去整，也就是破坏bss段上面的
//2个字节
SECTIONS {
.text 0 : { *(.text) }
.rodata : { *(.rodata) }
.data 0x30000000 : AT(0x700)
{
data_load_addr = LOADADDR(.data);
. = ALIGN(4);
data_start = . ;
*(.data)
data_end = . ;
}
. = ALIGN(4);//让当前地址向4对齐
bss_start = .;
.bss : { *(.bss) *(.COMMON) }
bss_end = .;
}
改进代码搬运为4字节访问
cpy:
ldr r4, [r1]
str r4, [r2]
add r1, r1, #4 //r1加4
add r2, r2, #4 //r2加4
cmp r2, r3 //如果r2 =< r3继续拷贝
ble cpy
/* 清除BSS段 */
ldr r1, =bss_start
ldr r2, =bss_end
mov r3, #0
clean:
str r3, [r1]
add r1, r1, #4
cmp r1, r2 //如果r1 =< r2则继续拷贝
ble clean
bl main //这里代码还是在nor上的，为什么能运行？因为代码在nor其实也没有什么关系
C处理
回头看 获得连接脚本的值 上面的章节
-
使用汇编给c传递参数,也就是先使用汇编
ldr r1,=__bss_start获得链接脚本的参数/* 重定位text, rodata, data段整个程序 */ mov r0, #0 ldr r1, =_start /* 第1条指令运行时的地址 */ ldr r2, =__bss_start /* bss段的起始地址 */ sub r2, r2, r1 /*长度*/ bl copy2sdram /* src, dest, len */ /* 清除BSS段 */ ldr r0, =__bss_start ldr r1, =_end bl clean_bss /* start, end */ -
c直接从链接脚本取值
///lds SECTIONS { . = 0x30000000; __code_start = .; //定义__code_start地址位当前地址 . = ALIGN(4); .text : { *(.text) } . = ALIGN(4); .rodata : { *(.rodata) } . = ALIGN(4); .data : { *(.data) } . = ALIGN(4); __bss_start = .; .bss : { *(.bss) *(.COMMON) } _end = .; } // c void copy2sdram(void) { /* 要从lds文件中获得 __code_start, __bss_start * 然后从0地址把数据复制到__code_start */ extern int __code_start, __bss_start;//声明外部变量 volatile unsigned int *dest = (volatile unsigned int *)&__code_start; volatile unsigned int *end = (volatile unsigned int *)&__bss_start; volatile unsigned int *src = (volatile unsigned int *)0; while (dest < end) { *dest++ = *src++; } } void clean_bss(void) { /* 要从lds文件中获得 __bss_start, _end */ extern int _end, __bss_start; volatile unsigned int *start = (volatile unsigned int *)&__bss_start; volatile unsigned int *end = (volatile unsigned int *)&_end; while (start <= end) { *start++ = 0; } }
位置无关码
- 使用相对跳转命令 b或bl;
- 重定位之前，不可使用绝对地址，不可访问全局变量/静态变量，也不可访问有初始值的数组(因为初始值放在rodata里，使用绝对地址来访问)；
- 重定位之后，使用ldr pc = xxx，跳转到/runtime地址；
写位置无关码，其实就是不使用绝对地址，判断有没有使用绝对地址，除了前面的几个规则，最根本的办法看反汇编。