• 嵌入式Linux入门-代码重定位和清除bss段讲解

    本文主要讲解代码重定位，以及清除bss段。

    在开始本文内容之前，需要学习一下，链接脚本的编写。 

    参考文章：链接器介绍和链接脚本的编写

     嵌入式Linux学习系列全部文章：嵌入式Linux学习—从裸机到应用教程大全

    一、重定位引入

    我们都知道S3C2440如下的内存模型

    假如是Nand启动

    上电后，S3C2440内部的Nand启动硬件会自动把Nand Flsh前4K复制到SRAM；

    CPU从0地址运行SRAM；

    如果程序大于4K，则前4K的代码需要把整个程序读出来放到SDRAM(即代码重定位)。

    假如是Nor Flash启动

    此时CPU认为的 0地址 在Nor Flash上面，片内内存SRAM的基地址就变成了0x40000000

    由于Nor Flash特性：可以像内存一样读，但不能像内存直接写，因此需要把全局变量和静态变量重定位放到SDRAM里。

    我们来看这样一段代码

    文件名：sdram.c

    1. #include "stdio.h"
    2.  
    3. char g_Char = 'A';　　／／定义一个全局变量
    4.  
    5. int sdram_init()
    6. {
    7.     ....../*略，sdram初始化*/
    8. }
    9. int main(void)
    10. {
    11.     sdram_init();
    12.  
    13.     while (1)
    14.     {
    15.         putchar(g_Char);　/*输出g_Char*／
    16.         g_Char++;         
    17.         delay(1000000);
    18.     }
    19.     return 0;
    20. }

    这段代码如果是Nand启动，就是正常的，如果是nor启动，就不正常，因为nor flash只能像sdram一样读，却不能正常写。

    二、重定位

    一个程序里面有

    • .text 代码段
    • .data 数据段
    • rodata 只读数据段(const全局变量)
    • bss段 (初始值为0，无初始值的全局变量)
    • commen 注释

    其中bss段和commen 注释不保存在bin文件中。

    为了解决Nor Flash里面的变量不能写的问题，我们把变量所在的数据段放在SDRAM里面，看行不行。
    修改Makefile 指定数据段为0x30000000 -Tdata 0x30000000:

    arm-linux-ld -Ttext 0 -Tdata 0x30000000  start.o  sdram.o -o sdram.elf

    这样的话编译出来的bin文件 从0地址 到 0x30000000地址 文件大小有700多MB，代码段和数据段直接有间隔，称之为黑洞


    解决黑洞有两个办法：

    方法一：只重定位数据段

    把数据段和代码段靠在一起；烧写在Nor Flash上面；运行时把全局变量复制到SDRAM，即0x3000000位置(重定位)；

    步骤：

    修改Makefile，使用链接脚本sdram.lds指定。

    arm-linux-ld -T sdram.lds start.o sdram.o -o sdram.elf

    我们需要依次排列 代码段、只读数据段、数据段、.bss段、.common。

    其中数据段放在0x700,但运行时在0x3000000：

    1. SECTIONS {
    2.    .text   0  : { *(.text) }//所有文件的.text
    3.    . = ALIGN(4);
    4.    .rodata  : { *(.rodata) } //只读数据段
    5.    . = ALIGN(4);
    6.    .data 0x30000000 : AT(0x700) { *(.data) } //放在0x700,但运行时在0x3000000
    7.    . = ALIGN(4);
    8.    .bss  : { *(.bss) *(.COMMON) }//所有文件的bss段，所有文件的.COMMON段
    9. }

    重新编译后烧写bin文件，发现启动后显示乱码。

    原因：

    我们从0x30000000处获取g_Char，但在这之前，并没有在0x30000000处准备好数据（0x30000000处没有初始化）。

    因此需要重定位数据段，将0x700的数据移动到0x30000000处，在start.S加入：

    1.  bl sdram_init
    2.  
    3.  /* 重定位data段 */
    4.  mov r1, #0x700 
    5.  ldr r0, [r1]
    6.  mov r1, #0x30000000
    7.  str r0, [r1]
    8.  
    9.  bl main

    上面的这种方法，只能复制0x700处的一位数据，不太通用，下面我们利用链接脚本中的符号，写一个更加通用的复制方法：

    链接脚本修改如下：

    1. SECTIONS {
    2.    .text   0  : { *(.text) }
    3.    . = ALIGN(4);
    4.    .rodata  : { *(.rodata) }
    5.    . = ALIGN(4);
    6.    .data 0x30000000 : AT(0x700) 
    7.    { 
    8.       data_load_addr = LOADADDR(.data);
    9.       data_start = . ;//等于当前位置
    10.       *(.data)  //等于数据段的大小
    11.       data_end = . ;//等于当前位置
    12.    }
    13.    . = ALIGN(4);
    14.    .bss  : { *(.bss) *(.COMMON) }
    15. }

    data_load_addr = LOADADDR(.data);这句话的意思就是data_load_addr=0x700

    data_start = . ;的意思就是data_start =0x30000000

    data_end = . ;的意思是data_end =0x30000000+数据段大小

    修改start.S

    1.     bl sdram_init   
    2.  
    3.     /* 重定位data段 */
    4.     ldr r1, =data_load_addr  /* data段在bin文件中的地址, 加载地址 */
    5.     ldr r2, =data_start      /* data段在重定位地址, 运行时的地址 */
    6.     ldr r3, =data_end        /* data段结束地址 */
    7.  
    8. cpy:
    9.     ldr r4, [r1]
    10.     str r4, [r2]
    11.     add r1, r1, #4 //r1加4
    12.     add r2, r2, #4 //r2加4
    13.     cmp r2, r3 //如果不等继续拷贝
    14.     ble cpy
    15.  
    16.     bl main

    方法二：重定位数据段和代码段

    让文件直接从0x30000000开始，全局变量在0x3……；烧写Nor Flash上 0地址处；

    运行会把整个代码段数据段(整个程序)从0地址复制到SDRAM的0x30000000(重定位)；

    先梳理下把整个程序复制到SDRAM需要哪些技术细节：
    1. 把程序从Flash复制到运行地址，链接脚本中就要指定运行地址为SDRAM地址；
    2. 编译链接生成的bin文件，需要在SDRAM地址上运行，但上电后却必须先在0地址运行，这就要求重定位之前的代码与位置无关(是位置无关码)；

    修改链接脚本：

    1. SECTIONS
    2. {
    3.     . = 0x30000000;
    4.  
    5.     . = ALIGN(4);
    6.     .text      :
    7.     {
    8.       *(.text)
    9.     }
    10.  
    11.     . = ALIGN(4);
    12.     .rodata : { *(.rodata) }
    13.  
    14.     . = ALIGN(4);
    15.     .data : { *(.data) }
    16.  
    17.     . = ALIGN(4);
    18.     __bss_start = .;
    19.     .bss : { *(.bss) *(.COMMON) }
    20.     _end = .;
    21. }

    现在我们写的这个链接脚本，称为一体式链接脚本，对比前面的分体式链接脚本区别在于代码段和数据段的存放位置是否是分开的。

    例如现在的一体式链接脚本的代码段后面依次就是只读数据段、数据段、bss段，都是连续在一起的。
    分体式链接脚本则是代码段、只读数据段，中间相关很远之后才是数据段、bss段。

    我们以后的代码更多的采用一体式链接脚本，原因如下：
    1. 分体式链接脚本适合单片机，单片机自带有flash，不需要再将代码复制到内存占用空间。而我们的嵌入式系统内存非常大，没必要节省这点空间，并且有些嵌入式系统没有Nor Flash等可以直接运行代码的Flash，就需要从Nand Flash或者SD卡复制整个代码到内存；
    2. JTAG等调试器一般只支持一体式链接脚本；

    修改start.S段

    1.     bl sdram_init
    2.  
    3.  /* 重定位text, rodata, data段整个程序 */
    4.     mov r1, #0
    5.     ldr r2, =_start         /* 第1条指令运行时的地址 */
    6.     ldr r3, =__bss_start    /* bss段的起始地址 */
    7.  
    8. cpy:
    9.     ldr r4, [r1]
    10.     str r4, [r2]
    11.     add r1, r1, #4
    12.     add r2, r2, #4
    13.     cmp r2, r3
    14.     ble cpy
    15.  
    16.     ldr pc, =main  
    17.  
    18. halt:
    19.     b halt

    将修改后的代码重新编译烧写在Nor Flash上，上电运行。

    注意了，为什么用 ldr pc, =main来跳转至main？而不用bl main？

    因为bl是相对跳转

    B命令的本质是跳转到: pc + offset，PC的值是当前指令，offset是跳转目标位置到当前位置的距离

    总结怎么写位置无关码

    使用相对跳转命令 b或bl;

    重定位之前，不可使用绝对地址，不可访问全局变量/静态变量，也不可访问有初始值的数组(因为初始值放在rodata里，使用绝对地址来访问)；

    重定位之后，使用ldr pc = xxx，跳转到runtime地址；

    三、清除BSS段

    bss段 (初始值为0，无初始值的全局变量)

    bin文件/elf文件都不保存bss段 这些都是初始值为0 或者没有初始化的全局变量，不保存能缩小文件。

    如果没有清除bss段操作，则初始值为0的全局变量的值不一定为0，所以需要程序去清除。

    修改lds链接文件

    1. SECTIONS {
    2.    .text   0  : { *(.text) }
    3.    .rodata  : { *(.rodata) }
    4.    .data 0x30000000 : AT(0x700) 
    5.    { 
    6.       data_load_addr = LOADADDR(.data);
    7.       data_start = . ;
    8.       *(.data) 
    9.       data_end = . ;
    10.    }
    11.  
    12.    bss_start = .; //bss开始地址是当前位置
    13.    .bss  : { *(.bss) *(.COMMON) }
    14.    bss_end = .; //bss结束地址也是当前位置

    修改start.s，清除bss段

    1. /* 清除BSS段 */
    2. ldr r1, =bss_start
    3. ldr r2, =bss_end
    4. mov r3, #0
    5. clean:
    6.     strb r3, [r1]
    7.     add r1, r1, #1
    8.     cmp r1, r2
    9.     bne clean

    现在的代码全局变量就是为0，如果初始值为0的全局变量很多，通过几行代码，就可以少几十个甚至上千个全局变量的存储空间。

    四、完整代码

    makefile

    1. all:	
    2. 	arm-linux-gcc -c -o start.o start.S
    3. 	arm-linux-gcc -c -o sdram.o sdram.c
    4. 	arm-linux-gcc -c -o main.o main.c
    5. 	arm-linux-ld -T sdram.lds start.o sdram.o main.o -o sdram.elf
    6. 	arm-linux-objcopy -O binary -S sdram.elf sdram.bin
    7. clean:
    8. 	rm *.bin *.o *.elf

    sdram.lds

    1. SECTIONS
    2. {
    3. 	. = 0x30000000;
    4.  
    5. 	. = ALIGN(4);
    6. 	.text :
    7. 	{
    8. 	  *(.text)
    9. 	}
    10.  
    11. 	. = ALIGN(4);
    12. 	.rodata : { *(.rodata) }
    13.  
    14. 	. = ALIGN(4);
    15. 	.data : { *(.data) }
    16.  
    17. 	. = ALIGN(4);
    18. 	__bss_start = .;
    19. 	.bss : { *(.bss) *(.COMMON) }
    20. 	_end = .;
    21. }

    start.s

    1. .text
    2. .global _start
    3.  
    4. _start:
    5.  
    6. 	/* 关闭看门狗 */
    7. 	ldr r0, =0x53000000
    8. 	ldr r1, =0
    9. 	str r1, [r0]
    10.  
    11. 	/* 设置MPLL, FCLK : HCLK : PCLK = 400m : 100m : 50m */
    12. 	/* LOCKTIME(0x4C000000) = 0xFFFFFFFF */
    13. 	ldr r0, =0x4C000000
    14. 	ldr r1, =0xFFFFFFFF
    15. 	str r1, [r0]
    16.  
    17. 	/* CLKDIVN(0x4C000014) = 0X5, tFCLK:tHCLK:tPCLK = 1:4:8  */
    18. 	ldr r0, =0x4C000014
    19. 	ldr r1, =0x5
    20. 	str r1, [r0]
    21.  
    22. 	/* 设置CPU工作于异步模式 */
    23. 	mrc p15,0,r0,c1,c0,0
    24. 	orr r0,r0,#0xc0000000   //R1_nF:OR:R1_iA
    25. 	mcr p15,0,r0,c1,c0,0
    26.  
    27. 	/* 设置MPLLCON(0x4C000004) = (92<<12)|(1<<4)|(1<<0) 
    28. 	 *  m = MDIV+8 = 92+8=100
    29. 	 *  p = PDIV+2 = 1+2 = 3
    30. 	 *  s = SDIV = 1
    31. 	 *  FCLK = 2*m*Fin/(p*2^s) = 2*100*12/(3*2^1)=400M
    32. 	 */
    33. 	ldr r0, =0x4C000004
    34. 	ldr r1, =(92<<12)|(1<<4)|(1<<0)
    35. 	str r1, [r0]
    36.  
    37. 	/* 一旦设置PLL, 就会锁定lock time直到PLL输出稳定
    38. 	 * 然后CPU工作于新的频率FCLK
    39. 	 */
    40.  
    41. 	ldr sp, =0x40000000+4096
    42. 	
    43. 	bl sdram_init
    44. 	
    45. 	/* 重定位text, rodata, data段整个程序 */
    46. 	mov r1, #0
    47. 	ldr r2, =_start 	 /* 第1条指令运行时的地址 */
    48. 	ldr r3, =__bss_start 	/* bss段的起始地址 */
    49.  
    50. cpy:
    51. 	ldr r4, [r1]
    52. 	str r4, [r2]
    53. 	add r1, r1, #4
    54. 	add r2, r2, #4
    55. 	cmp r2, r3
    56. 	ble cpy
    57. 	
    58. 	/* 清除BSS段 */
    59. 	ldr r1, =__bss_start
    60. 	ldr r2, =_end
    61. 	mov r3, #0
    62. clean:
    63. 	strb r3, [r1]
    64. 	add r1, r1, #1
    65. 	cmp r1, r2
    66. 	bne clean
    67.  
    68. 	ldr pc, =main
    69.  
    70. halt:
    71. 	b halt

    sdram.c

    1. #define BWSCON (*(volatile unsigned int *)0x48000000)
    2. #define BANKCON6 (*(volatile unsigned int *)0x4800001C)
    3. #define REFRESH (*(volatile unsigned int *)0x48000024)
    4. #define BANKSIZE (*(volatile unsigned int *)0x48000028)
    5. #define MRSRB6 (*(volatile unsigned int *)0x4800002C)
    6.  
    7. int sdram_init(void)
    8. {
    9. 	BWSCON = 0x22000000;
    10. 	BANKCON6 = 0x18001;
    11. 	REFRESH = 0x008404f5;
    12. 	BANKSIZE = 0xb1;
    13. 	MRSRB6 = 0x00000020;
    14. }

    main.c

    1. #include <stdio.h>
    2. #define GPFCON (*(volatile unsigned int *)0x56000050)
    3. #define GPFDAT (*(volatile unsigned int *)0x56000054)
    4. char g_char='A';
    5. int g_int=0;
    6. void delay(volatile int d)
    7. {
    8. 	while (d--);
    9. }
    10. int main(void)
    11. {	
    12. 	int i=0;
    13. 	while(i!=5)
    14. 	{
    15. 		if(g_char=='A')
    16. 		{
    17. 		GPFCON = 0x00000100;
    18. 		GPFDAT = 0;
    19. 		}
    20. 		delay(200000);
    21. 		if(g_int==0)
    22. 		{
    23. 		GPFDAT = 0xff;
    24. 		}
    25. 		delay(200000);
    26. 		i++;
    27. 	}
    28. 	g_char='B';
    29. 	while(1)
    30. 	{
    31. 		if(g_char=='B')
    32. 		{
    33. 		GPFDAT = 0;
    34. 		}
    35. 	}		
    36. 	return 0;
    37. }

    功能：验证全局变量g_char是否成功重定位，成功则灯亮

    验证全局变量g_int是否成功被清0，成功则灯灭，

    循环5次，验证g_char写入是否正常。

    全部正常则：灯循环亮灭5次，然后长亮。

  • 相关阅读:
    【C语言】结构类型的定义和使用
    Linux zip命令：压缩文件或目录
    期货开户手续费加一分是主流
    Spark 运行架构与原理
    postman进行批量测试的步骤
    modbusRTU【codesys】
    STM32-LCD中英文显示及应用
    Oracle表索引查看方法总结（查看oracle表索引）
    I/O 设备（输入/输出设备）
    [附源码]java毕业设计文档管理系统
  • 原文地址：https://blog.csdn.net/freestep96/article/details/126586710