ARM-GCC-LD脚本入门讲解

基础

什么是链接脚本

链接脚本是由链接器使用的文件，用于控制程序的内存布局，指定代码和数据在内存中的位置。

链接脚本可以确保代码和数据被放置在正确的位置，避免冲突和溢出问题。

编译、汇编和链接的基本概念

• 编译：将源代码（如C或C++）转换为汇编语言。
• 汇编：将汇编语言转换为机器代码。
• 链接：将多个对象文件和库合并成一个单一的可执行文件。

各种内存区域 (RAM, ROM, Stack, Heap)

• RAM：用于存储变量和程序数据。
• ROM：用于存储程序代码和常量数据。
• Stack：用于存储局部变量和函数调用的返回地址。
• Heap：用于动态内存分配。

内存分配策略

两种主要的内存分配策略: 静态内存分配和动态内存分配

静态内存分配是在编译时进行的，它的大小和位置在程序运行期间是不变的。全局变量和局部静态变量是静态内存分配的例子。优点：无需担心内存泄露问题；缺点：可能造成内存浪费，内存分配不灵活。

态内存分配允许你在运行时分配内存。你可以根据需要创建新的对象或释放不再需要的对象。 优点：灵活处理，按需分配；缺点：容易出现内存泄露和碎片化问题。

链接脚本的组成

链接脚本主要包含MEMORY和SECTIONS

在MEMORY区块中，我们可以定义各种内存区域及其属性，如只读(ROM)或读写(RAM)，或者FLASH等。我们还可以定义每个区域的大小和起始地址。

SECTIONS的定义及其内部段的详解 (.text, .data, .bss等)

• .text：存放程序代码和常量数据。
• .data：存放已初始化的全局和静态变量。
• .bss：存放未初始化的全局和静态变量。

MEMORY的语法

MEMORY
{
name (attr) : ORIGIN = origin, LENGTH = len
...
}

name：一个用户定义的名字，Linker将在内部使用它，所以别把它和SECTIONS里用到的文件名，段名等搞重复了，它要求是独一无二的。

attr ：如同它的名字一样，这是内存段的属性描述。

R' Read-only sections. W’ Read/write sections.
X' Sections containing executable code. A’ Allocated sections.
I' Initialized sections. L’ Same as I.
`!’ Invert the sense of any of the following attributes.

ORIGIN：这是起始地址

LENGTH：段长

SECTIONS的语法

SECTION> [ADDRESS] [(TYPE)] : [AT(LMA)]
{
OUTPUT-SECTION-COMMAND
OUTPUT-SECTION-COMMAND
...
} [>REGION] [AT>LMA_REGION] [:PHDR :PHDR...] [=FILLEXP]

其中：

SECTION 为输出段的名字定义

[ADDRESS]为输出段的VMA 虚拟地址

[(TYPE)] 为输出段的类型

[AT(LMA)] 为输出段的LMA 加载地址

[>REGION] 为输出段的VMA 地址依次累加

[AT>LMA_REGION]为输出段的LMA 地址依次累加

[:PHDR :PHDR…]，[=FILLEXP] 很少用

OUTPUT-SECTION-COMMAND为输入段的模式匹配，定义那输入些段会被放到这个输出段中

需要注意的是**[ADDRESS]** 和 [AT(LMA)]必须指定具体的地址。[>region] 和 **[AT>LMA region]**只需指定MEMORY定义的内存空间，具体地址紧接着上一个output section的末尾地址。

另一种语法表示

SECTIONS
{
...
secname start BLOCK(align) (NOLOAD) : AT ( ldadr )
{ contents } >region :phdr =fill
...
}

这么多的参数中，只有secname和contents是必须的，其他都是可选的参数。 secname前后的两个空格是必须的，否则就是不合法输入。

secname：定义段，但是别以为定义的段一定要是教科书上写的.data，.text这些科班的必须品，你甚至可以创建一个段来放一个美女的图片。

contents：它的语法开始复杂起来了，但是你可以简单的把输入文件写到代码中：

.data : { main.o led.o}

但是结果被列的目标文件中所有的代码都被链接到.data中去了，显然不大符合我们的要求啊。那么还有一种写法：

.data : {
main.o（.data）
main.o（.text）// 也可以这样写 main.o(.data .text)或者main.o(.data , .text)
led.o（.data）
}

这个写法让只有被选中的文件的特殊段被链接到输出文件的.data段了。当然，我们似乎还有更好的写法：

.data : {
*（.data）
}

这样的话，所有目标文件的.data段都被连接到了输出文件中了。

start：强制链接地址。 强迫链接器将当前的段连接到指定的地址中。

.data 0x400000000 : { … }

BLOCK(align)： 用的时候用的比较多的是ALIGN（4）这样的标记，表示排列地址的时候按4的倍数排列

AT（addr）：指定在文件中存放的位置

region： 这个region就是前面说的MEMORY命令定义的位置信息。

.表示当前地址

什么是当前的地址啊？就是链接器在连接的时候根据前面的段排列后的当前位置。

**RAM_START = .;**定义了一个RAM_START变量，地址是当前的地址

. = 0x00000000定义当前地址为0x0。

举例

链接文件

MEMORY
{
  FLASH (rx) : ORIGIN = 0x80000000, LENGTH = 8M 
  RAM (xrw)  : ORIGIN = 0x70000000, LENGTH = 1M   
}

这部分定义了芯片中的主要内存区域：FLASH 和 RAM。ORIGIN 指定了内存区域的起始地址，而 LENGTH 则定义了区域的大小。

SECTIONS
{
  .text :
  {
    KEEP(*(.isr_vector))
    *(.text*)
    *(.rodata*)
    _etext = .;
  } > FLASH

这里我们定义了 .text 段，其中包含程序的代码和只读数据。它被放置在 FLASH 内存中。 _etext 符号标记了该段的结束。

  .data :
  {
    _sdata = .;
    *(.data*)
    _edata = .;
  } > RAM AT> FLASH

.data 段存放初始化的全局和静态变量。它在 RAM 中创建但是其初始值存储在 FLASH 中。

  .bss :
  {
    _sbss = .;
    *(.bss*)
    _ebss = .;
  } > RAM

.bss 段存放未初始化的全局和静态变量。它只在 RAM 中创建，不占用任何 FLASH 空间。

  .stack :
  {
    . = ALIGN(8);
    _sstack = .;
    . += 0x1000;
    _estack = .;
  } > RAM

此部分定义了堆栈区域，其开始和结束由 _sstack 和 _estack 标记。我们还确保它按8字节对齐，然后分配了0x1000字节的空间给它。

  .heap :
  {
    . = ALIGN(8);
    _sheap = .;
    . += 0x1000;
    _eheap = .;
  } > RAM
}

此部分定义了堆区域，其开始和结束由 _sheap 和 _eheap 标记。和堆栈一样，它也被8字节对齐并分配了0x1000字节的空间。

C代码

extern uint32_t _sdata, _edata, _etext, _sbss, _ebss;

这行代码声明了在链接脚本中定义的符号，以便我们可以在 C 代码中引用它们。

void LowLevelInit(void) {
    uint32_t *pSrc, *pDest;

    // Initialize data section
    pSrc = &_etext;
    pDest = &_sdata;
    while (pDest < &_edata) {
        *pDest++ = *pSrc++;
    }

    // Clear the bss section
    pDest = &_sbss;
    while (pDest < &_ebss) {
        *pDest++ = 0;
    }
}

在 LowLevelInit 函数中，我们初始化 .data 段和清除 .bss 段。对于 .data 段，我们将其初始值从 FLASH 复制到 RAM。对于 .bss 段，我们将它设置为0。

int main(void) {
    LowLevelInit();

    // Now, you can call your AUTOSAR application startup code
    // ...

    return 0;
}

在 main 函数中，我们首先调用 LowLevelInit 来完成底层的初始化,然后再进行后续操作。

定义全局变量

int global_var = 42;       // Will be placed in the .data section
int uninit_global_var;     // Will be placed in the .bss section

内存管理

有了我们定义的堆区域，你可以实现和使用动态内存分配函数如 malloc 和 free。你可以使用 _sheap 和 _eheap 符号来定义堆的边界。

extern uint32_t _sheap, _eheap;

void *malloc(size_t size) {
    // Implement a simple malloc function using _sheap and _eheap
    // ...
}

void free(void *ptr) {
    // Implement a simple free function
    // ...
}

可以使用 _sstack, _estack, _sheap, 和 _eheap 符号来监视或调试你的堆栈和堆使用情况。

在你的 C 代码中，你可以引用由链接脚本生成的各种符号来获取函数或数据的地址。例如：

extern uint32_t _etext;

void foo(void) {
    uint32_t func_address = (uint32_t)&foo;
    uint32_t etext_address = (uint32_t)&_etext;
    // ...
}

在这个例子中，我们获取了 foo 函数的地址和 _etext 符号的地址。

使用链接脚本

gcc -T linkerscript.ld -o my_app.elf my_app.c

在这个命令中，-T linkerscript.ld 指定了使用我们的链接脚本，-o my_app.elf 指定了输出文件的名字，my_app.c 是你的源代码文件。

实例

创建add.c文件，data.c 和main.c文件三个文件，并且写自己定义的链接脚本将这个三个.c文件链接为一个输出文件。

main.c
----------------
extern int add(int a , int b);
extern int data1;
extern int data2;
int main(void){
        add(data1,data2)
        return 0;
}

data.c
-----------------
int data1=10;
int data2=20;

add.c
-----------------
int add(int a , int b){
    return a+b;
}

使用arm gcc 生成每个.c对应的.o文件

arm-none-eabi-gcc -c main.c
arm-none-eabi-gcc -c data.c
arm-none-eabi-gcc -c add.c

使用objdump工具观察编译生成的*.o文件的内容，分别观察.text .data的Size, VMA(装载内存地址), LMA(虚拟内存地址)等。

arm-none-eabi-objdump -h main.o
arm-none-eabi-objdump -h data.o
arm-none-eabi-objdump -h add.o

更清晰地查看每个段的含义：

arm-none-eabi-objdump -s -d main.o > main.o.txt

查看反汇编信息main.o.txt

...
Disassembly of section .text:
00000000 <main>:
   0:   e92d4800        push    {fp, lr}
   ...
2c:   ebfffffe        bl      0 <add>
...

其中ebfffffe bl 0 <add>有一个标签<add>,bl目前跳转的地方是0地址，后期连接器应该是需要把这个值改回来的。

思考：现在有三个.o文件，分别是data.o add.o main.o 其中data.o放了两个全局变量的具体取值，add.o存放了使得两个整形数相加的函数实现，main.o则是使用了data.o的数据，add.o的函数。main.o在链接之前并不知道数据的具体数值，也不知道调用函数的函数位置，因此事先会把不知道的信息空出来，等到链接的时候再合并。因此接下来要观察链接的结果。

假设，我们目标的memorymap ，数据段存放在0x10000位置，代码段存放再0x80000的位置。

my.ld

SECTIONS { 
  . = 0x10000; 
  .text : {*(.text)}   
  . = 0x80000;   
  .data : {*(.data)}   
  .bss : {*(.bss)} 
}

使用连接器链接

arm-none-eabi-ld add.o data.o main.o -T my.ld -o out

得到输出文件out

反汇编out查看是否符合预期。

参考文献

ARM-GCC-LD脚本 - 知乎 (zhihu.com)

嵌入式软件之链接脚本 .ld - 知乎 (zhihu.com)

ld - 链接脚本学习笔记与实践过程 - 知乎 (zhihu.com)

链接脚本再探和VMA与LMA - Little_Village - 博客园 (cnblogs.com)