ARM链接脚本详解

标签：输出 文件 text 符号 链接 地址 详解 data ARM

1. 概论 

每一个链接过程都由链接脚本(linker script, 一般以lds作为文件的后缀名)控制. 链接脚本主要用于规定如何把输入文件内的段放入输出文件内, 并控制输出文件内各部分在程序地址空间内的布局. 但你也可以用连接命令做一些其他事情.

2. 基本概念

链接器把一个或多个输入文件合成一个输出文件.

输入文件:  目标文件或链接脚本文件.
输出文件:  目标文件或可执行文件.
目标文件(包括可执行文件)具有固定的格式, 在UNIX或GNU/Linux平台下, 一般为ELF格式. 若想了解更多, 可参考 UNIX/Linux平台可执行文件格式分析

有时把输入文件内的段称为输入段(input 段), 把输出文件内的段称为输出段(output sectin).

目标文件的每个段至少包含两个信息: 名字和大小. 大部分段还包含与它相关联的一块数据, 称为段 contents(段内容). 一个段可被标记为“loadable(可加载的)”或“allocatable(可分配的)”.

loadable 段: 在输出文件运行时, 相应的段内容将被载入进程地址空间中，如.text段、.data段。

allocatable 段: 内容为空的段可被标记为“可分配的”. 在输出文件运行时, 在进程地址空间中空出大小同段指定大小的部分. 某些情况下, 这块内存必须被置零。如.bss段。

如果一个段不是“可加载的”或“可分配的”，那么该段通常包含了调试信息.，可用objdump -h命令查看相关信息。

• 每个“可加载的”或“可分配的”输出段通常包含两个地址

第一个是'VMA'或称为虚拟内存地址. 这是当输出文件运行时，段所拥有的地址.

第二个是‘LMA', 或称为载入内存地址. 这个段即将要载入的内存地址.

     一般而言， 某段的VMA == LMA。 但在嵌入式系统中, 经常存在加载地址和执行地址不同的情况: 比如将输出文件加载到开发板的flash中(由LMA指定), 而在运行时将位于flash中的输出文件复制到SDRAM中(由VMA指定).

符号(symbol): 每个目标文件都有符号表(SYMBOL TABLE)，包含已定义的符号(对应全局变量和static变量和定义的函数的名字)和未定义符号(未定义的函数的名字和引用但没定义的符号)信息.

符号值: 每个符号对应一个地址， 即符号值(这与c程序内变量的值不一样, 某种情况下可以把它看成变量的地址). 可用nm命令查看它们.

 

3. 脚本格式

在介绍SECTIONS的用法之前，我们先对之前提到的LMA和VMA进行说明：每个output section都有一个LMA和一个VMA，LMA是其存储地址，而VMA是其运行时地址，例如将全局变量g_Data所在数据段.data的LMA设为0x80000020（属于ROM地址），VMA设为0xD0004000（属于RAM地址），那么g_Data的值将存储在ROM中的0x80000020处，而程序运行时，用到g_Data的程序会到RAM中的0xD0004000处寻找它。

1.   SECTIONS {
2.   ...
3.   secname start BLOCK(align) (NOLOAD) : AT ( ldadr )
4.   { contents } >region :phdr =fill
5.   ...
6.   }

 

其中，secname 和 contents 是必须有的，其他是可选的。

1）secname 指定了输出段的名称，比如 .text、.data。

2）contents 指定了输出段的内容，它可以是输入文件，或者是输入文件中的某一个段，例如：

1.   .data : {
2.   afile.o bfile.o cfile.o
3.   }

 

3）start 指定该段的起始地址（强制链接地址）

4）BLOCK(align) 指定段起始的对齐大小

5）(NOLOAD) 防止一个段被多次加载进内存

6）AT(ldar) 指定段的加载地址，实现存放地址和加载地址不一致的功能，AT表示在文件中存放的位置，在内存里面时按照普通的方式存放

7）>region 给该段指定一个已定义的内存区域，就是MEMORY命令定义的位置信息

8) :phdr 将该段分配给一个或多个程序段 (segment(s) described by a program header)

9）=fill 指定该段的初始填充值

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

指定LMA和VMA，有4种方法：

　　a) [<address>] + [AT(<lma>)]；

　　b) [<address>] + [AT><lma region>]；

　　c) [><region>] + [AT><lma region>]；

　　d) [><region>] + [AT(<lma>)].

　　但是要注意这些用法的不同：[<address>] 和 [AT(<lma>)]必须指定具体的地址，而 [><region>] 和 [AT><lma region>]只需指定内存空间，具体地址紧接着上一个output section的末尾地址。

　　经过以上步骤，我们得出如下section定义：（这里只列出2种）

1.   SECTIONS
2.   {
3.   　　.my_data ( 0xD0004000 ) : AT ( 0x80000020 )
4.   　　{
5.   　　　　*(.myData)
6.   　　}　　...
7.   }

1.   SECTIONS
2.   {
3.   　　.my_data :
4.   　　{
5.   　　　　*(.myData)
6.   　　} > ram AT> rom　　...
7.   }

 以上为了说明SECTION的语法，使用了全局变量这种LMA和VMA不同的例子。而对于代码段.text这种LMA与VMA相同的情况，由于默认情况下LMA=VMA，因此可以只定义VMA而不必指明LMA，例如：

1.   .text :
2.   {
3.   *(.text)
4.   *(.text.*)
5.   . = ALIGN(4);
6.   } > pfls0

4. 简单例子

在介绍链接描述文件的命令之前, 先看看下述的简单例子:

以下脚本将输出文件的text 段定位在0×10000, data 段定位在0×8000000:

1.   SECTIONS
2.   {
3.   . = 0×10000;
4.   .text :     { *(.text) }
5.   . = 0×8000000;
6.   .data :   { *(.data) }
7.   .bss :     { *(.bss) }
8.   }

解释一下上述的例子:
. = 0×10000 : 把定位器符号置为0×10000 (若不指定, 则该符号的初始值为0).

.text : { *(.text) } : 将所有(*符号代表任意输入文件)输入文件的.text 段合并成一个.text 段, 该段的地址由定位器符号的值指定, 即0×10000.

. = 0×8000000 ：把定位器符号置为0×8000000
.data : { *(.data) } : 将所有输入文件的.data 段合并成一个.data 段, 该段的地址被置为0×8000000.

.bss : { *(.bss) } : 将所有输入文件的.bss 段合并成一个.bss 段，该段的地址被置为0×8000000+.data 段的大小.

连接器每读完一个段描述后, 将定位器符号的值*增加*该段的大小. 注意: 此处没有考虑对齐约束.

 

5. 简单脚本命令

- 1 -ENTRY(SYMBOL) : 将符号SYMBOL的值设置成入口地址。

入口地址(entry point): 进程执行的第一条用户空间的指令在进程地址空间的地址)

ld有多种方法设置进程入口地址, 按一下顺序: (编号越前, 优先级越高)
1, ld命令行的-e选项
2, 连接脚本的ENTRY(SYMBOL)命令
3, 如果定义了start符号, 使用start符号值
4, 如果存在.text 段, 使用.text 段的第一字节的位置值
5, 使用值0

- 2 -INCLUDE filename : 包含其他名为filename的链接脚本

相当于c程序内的的#include指令, 用以包含另一个链接脚本.

脚本搜索路径由-L选项指定. INCLUDE指令可以嵌套使用, 最大深度为10. 即: 文件1内INCLUDE文件2, 文件2内INCLUDE文件3… , 文件10内INCLUDE文件11. 那么文件11内不能再出现 INCLUDE指令了.

- 3 -INPUT(files): 将括号内的文件做为链接过程的输入文件

ld首先在当前目录下寻找该文件，如果没找到， 则在由-L指定的搜索路径下搜索。 file可以为 -lfile形式，就象命令行的-l选项一样， 如果该命令出现在暗含的脚本内，则该命令内的file在链接过程中的顺序由该暗含的脚本在命令行内的顺序决定.

- 4 -GROUP(files) : 指定需要重复搜索符号定义的多个输入文件

除了file必须是库文件以外，该命令与INPUT相似， 且file文件作为一组被ld重复扫描，直到不在有新的未定义的引用出现。

- 5 -OUTPUT(FILENAME) : 定义输出文件的名字

同ld的-o选项, 不过-o选项的优先级更高. 所以它可以用来定义默认的输出文件名. 如a.out

- 6 -SEARCH_DIR(PATH) ：定义搜索路径，

同ld的-L选项, 不过由-L指定的路径要比它定义的优先被搜索。

- 7 -STARTUP(filename) : 指定filename为第一个输入文件

在链接过程中, 每个输入文件是有顺序的. 此命令设置文件filename为第一个输入文件。就象这个文件是在命令行上第一个被指定的文件一样， 如果在一个系统中,，入口点总是存在于第一个文件中，那这个就很有用。

- 8 – OUTPUT_FORMAT(BFDNAME) : 设置输出文件使用的BFD格式

同ld选项-o format BFDNAME, 不过ld选项优先级更高.

- 9 -OUTPUT_FORMAT(DEFAULT,BIG,LITTLE) : 定义三种输出文件的格式(大小端)

对于此命令，要在命令行中使用-EB或-EL选项来指定不同的输出文件格式

如果'-EB'和'-EL'都没有使用, 那输出格式会是第一个参数 DEFAULT,

如果使用了'-EB',输出格式会是第二个参数 BIG,

如果使用了'-EL', 输出格式会是第三个参数, LITTLE.

比如：缺省的基于 MIPS ELF 平台连接脚本使用如下命令:

OUTPUT_formAT(elf32-bigmips, elf32-bigmips, elf32-littlemips)

这表示缺省的输出文件格式是'elf32-bigmips', 但是当用户使用'-EL'命令行选项的时候, 输出文件就会被以`elf32-littlemips'格式创建.

- 10- TARGET(BFDNAME)：设置输入文件的BFD格式

同ld选项-b BFDNAME. 若使用了TARGET命令, 但未使用OUTPUT_FORMAT命令, 则最用一个TARGET命令设置的BFD格式将被作为输出文件的BFD格式.

• 其他链接脚本命令:

ASSERT(EXP, MESSAGE)：      如果EXP不为真，终止连接过程

EXTERN(SYMBOL SYMBOL …)：在输出文件中增加未定义的符号，如同连接器选项-u

FORCE_COMMON_ALLOCATION：为common symbol(通用符号)分配空间，即使用了-r连接选项也为其分配

NOCROSSREFS(SECTION SECTION …)：检查列出的输出段，如果发现他们之间有相互引用，则报错。对于某些系统，特别是内存较紧张的嵌入式系统，某些段是不能同时存在内存中的，所以他们之间不能相互引用。

OUTPUT_ARCH(BFDARCH)：设置输出文件的machine architecture(体系结构)，BFDARCH为被BFD库使用的名字之一。可以用命令objdump -f查看。

可通过 man -S 1 ld查看ld的联机帮助, 里面也包括了对这些命令的介绍.

6. 对符号的赋值

       在目标文件内定义的符号可以在链接脚本内被赋值. (注意和C语言中赋值的不同!) 此时该符号被定义为全局的， 每个符号都对应了一个地址, 此处的赋值是更改这个符号对应的地址.

注意：在链接脚本中给符号赋值，赋的是符号对应的地址值，而不是普通的值。

1.   e.g. 通过下面的程序查看变量a的地址:
2.   /* a.c */
3.   #include
4.   int a = 100;
5.   int main(void)
6.   {
7.   printf( “&a=0x%p “, &a );
8.   return 0;
9.   }
10.    
11.   $ gcc -Wall -o a-without-lds a.c
12.   &a = 0×8049598
13.    
14.   /* a.lds */
15.   a = 3;
16.    
17.   $ gcc -Wall -o a-with-lds a.c a.lds
18.   &a = 0×3

注意: 对符号的赋值只对全局变量起作用!

一些简单的赋值语句
能使用任何c语言内的赋值操作:

1.   SYMBOL = EXPRESSION ;
2.   SYMBOL += EXPRESSION ;
3.   SYMBOL -= EXPRESSION ;
4.   SYMBOL *= EXPRESSION ;
5.   SYMBOL /= EXPRESSION ;
6.   SYMBOL <<= EXPRESSION ;
7.   SYMBOL >>= EXPRESSION ;
8.   SYMBOL &= EXPRESSION ;
9.   SYMBOL |= EXPRESSION ;

第一个情况会把 SYMBOL 定义为值 EXPRESSION.

其它情况下, SYMBOL 必须是已经定义了的，而值会作出相应的调整.

. 是一个特殊的符号，它是定位器，一个位置指针，指向程序地址空间内的某位置，该符号只能在SECTIONS命令内使用

注意：赋值语句包含4个语法元素：符号名、操作符、表达式、分号；一个也不能少。

被赋值后，符号所属的段被设置为表达式EXPRESSION所属的段(参看11. 脚本内的表达式)
赋值语句可以出现在连接脚本的三处地方：单独的部分，SECTIONS命令内，SECTIONS命令内的段描述内；如下，

1.   floating_point = 0; /* 全局位置 */
2.   SECTIONS
3.   {
4.   .text :
5.   {
6.   *(.text)
7.   _etext = . ;                          /* 段描述内 */
8.   }
9.   _bdata = (. + 3) & ~ 4;      /* SECTIONS命令内 */
10.   .data : { *(.data) }
11.   }

PROVIDE关键字
该关键字用于定义这类符号：在目标文件内被引用，但没有在任何目标文件内被定义的符号。

1.   例子：
2.   SECTIONS
3.   {
4.   .text :
5.   {
6.   *(.text)
7.   _etext = .;
8.   PROVIDE(etext = .);
9.   }
10.   }
11.   在

这个例子中，如果程序定义了一个'_etext'(带有一个前导下划线),，连接器会给出一个重定义错误。当程序内引用etext符号时，如果程序内定义了etext，则默认程序中的定义。如果没定义，etext符号对应的地址被定义为.text 段之后的第一个字节的地址。

7. SECTIONS命令

      SECTIONS命令告诉连接器如何把输入段映射到输出段, 并如何把输出段放入到内存中.

该命令格式如下:

1.   SECTIONS
2.   {
3.   SECTIONS-COMMAND
4.   SECTIONS-COMMAND
5.   …
6.   }

SECTION-COMMAND有四种:
(1) ENTRY命令
(2) 符号赋值语句
(3) 一个输出段的描述(output 段 description)
(4) 一个段叠加描述(overlay description)

• 'ENTRY'命令和符号赋值在'SECTIONS'命令中是允许的, 这是为了方便在这些命令中使用定位计数器. 这也可以让连接脚本更容易理解, 因为你可以在更有意义的地方使用这些命令来控制输出文件的布局.

如果整个连接脚本内没有SECTIONS命令, 那么链接器将所有同名输入段合成为一个输出段内, 各输入段的顺序为它们被连接器发现的顺序.    

如果某输入段没有在SECTIONS命令中提到，那么该段将被直接拷贝成输出段。

• 输出段描述和重叠描述在下面描述.

输出段描述具有如下格式:

1.   SECTION [ADDRESS] [(TYPE)] : [AT(LMA)]
2.   {
3.   OUTPUT-SECTION-COMMAND
4.   OUTPUT-SECTION-COMMAND
5.   …
6.   } [>REGION] [AT>LMA_REGION] [:PHDR  HDR...] [=FILLEXP]

注意：这里SECTION和SECTIONS命令不一样。SECTION是SECTIONS命令内的一个输出段描述符

[ ]内的内容为可选选项, 一般不需要.
SECTION：段名字
SECTION左右的空白、圆括号、冒号是必须的，换行符和其他空格是可选的。
每个OUTPUT-SECTION-COMMAND为以下四种之一，

• 符号赋值语句
• 一个输入段描述
• 直接包含的数据值
• 一个特殊的输出段关键字

（1）输出段名字(SECTION)：
        输出段名字必须符合输出文件格式要求，比如：a.out格式的文件只允许存在.text、.data和.bss 段名。

        而有的格式只允许存在数字名字，那么此时应该用引号将所有名字内的数字组合在一起；

       另外，还有一些格式允许任何序列的字符存在于 段名字内，此时如果名字内包含特殊字符(比如空格、逗号等)，那么需要用引号将其组合在一起。

• 输出段地址(ADDRESS)：

ADDRESS是一个表达式，它的值用于设置VMA。

如果你不提供 ADDRESS, 连接器会基于 REGION(如果存在)设置它，或者基于定位计数器的当前值.

如果你提供了 ADDRESS, 那输出段的地址会被精确地设为这个值.

如果你既不提供 ADDRESS 也不提供 REGION, 那输出节段的地址会被设为当前的定位计数器向上对齐到输出段需要的对齐边界的值.

1.   例子：
2.   .text  .  :  { *(.text) }
3.   和
4.   .text  :  { *(.text) }

第一个会把'.text'输出段的地址，设为当前定位计数器的值.

第二个会把它设为定位计数器的当前值向上对齐到'.text'输入段中对齐要求最严格的一个边界.

ADDRESS可以是一个任意表达式：

比如,如果你需要把节对齐一个字的边界，这样就可以让低四字节的节地址值为零, 你可以这样做:

.text  ALIGN(0x10) : { *(.text) }

这个语句可以正常工作，因为'ALIGN'返回 定位计数器对齐到0x10边界后的值 。

指定一个节的地址会改变定位计数器的值。

（2）输入段描述：
最常见的输出段描述命令是输入段描述。
输入段描述是最基本的连接脚本描述。
输入段描述基础：

一个输入段描述，由一个文件名后跟有可选的括号中的段名列表组成。文件名和段名可以通配符形式出现。

例如：*(.text)       包含所有文件的.text段

基本语法：FILENAME([EXCLUDE_FILE (FILENAME1 FILENAME2 ...) SECTION1 SECTION2 ...)

FILENAME文件名，可以是一个特定的文件的名字，也可以是一个字符串模式。
SECTION名字，可以是一个特定的段名字，也可以是一个字符串模式
 

例子是最能说明问题的：
 

1.   *(.text) ：                表示所有输入文件的.text 段
2.   (*(EXCLUDE_FILE (*crtend.o *otherfile.o) .ctors)) ：表示除crtend.o、otherfile.o文件外的所有输入文件的.ctors 段。
3.   data.o(.data) ：     表示data.o文件的.data 段
4.   data.o ：                表示data.o文件的所有段
5.   *(.text .data) ：     表示所有文件的.text 段和.data 段，顺序是：第一个文件的.text 段，第一个文件的.data 段，第二个文件的.text 段，第二个文件的.data 段，...
6.   *(.text) *(.data) ：    表示所有文件的.text 段和.data 段，顺序是：第一个文件的.text 段，第二个文件的.text 段，...，最后一个文件的.text 段，第一个文件的.data 段，第二个文件的.data 段，...，最后一个文件的.data 段

下面看连接器是如何找到对应的文件的。
当FILENAME是一个特定的文件名时，连接器会查看它是否在连接命令行内出现或在INPUT命令中出现。
当FILENAME是一个字符串模式时，连接器仅仅只查看它是否在连接命令行内出现。
注意：如果连接器发现某文件在INPUT命令内出现，那么它会在-L指定的路径内搜寻该文件。（3）字符串模式内可存在以下通配符：

1.   * ：表示任意多个字符
2.   ? ：表示任意一个字符
3.   [CHARS] ：表示任意一个CHARS内的字符，可用-号表示范围，如：a-z
4.   ：表示引用下一个紧跟的字符
5.    
6.   在文件名内，通配符不匹配文件夹分隔符/，但当字符串模式仅包含通配符*时除外。
7.   任何一个文件的任意段只能在SECTIONS命令内出现一次。看如下例子，
8.   SECTIONS {
9.   .data : { *(.data) }
10.   .data1 : { data.o(.data) }
11.   }

data.o文件的.data 段在第一个OUTPUT-SECTION-COMMAND命令内被使用了，那么在第二个OUTPUT-SECTION-COMMAND命令内将不会再被使用，也就是说即使连接器不报错，输出文件的.data1 段的内容也是空的。
再次强调：连接器依次扫描每个OUTPUT-SECTION-COMMAND命令内的文件名，任何一个文件的任何一个段都只能使用一次。
读者可以用-M连接命令选项来产生一个map文件，它包含了所有输入段到输出段的组合信息。

再看个例子，

1.   SECTIONS {
2.   .text : { *(.text) }
3.   .DATA : { [A-Z]*(.data) }
4.   .data : { *(.data) }
5.   .bss : { *(.bss) }
6.   }

这个例子中说明，所有文件的输入.text 段组成输出.text 段；所有以大写字母开头的文件的.data 段组成输出.DATA 段，其他文件的.data 段组成输出.data 段；所有文件的输入.bss 段组成输出.bss 段。

可以用SORT()关键字对满足字符串模式的所有名字进行递增排序，如SORT(.text*)。

（4）通用符号(common symbol)的输入段：
       在许多目标文件格式中，通用符号并没有占用一个段。连接器认为：输入文件的所有通用符号在名为COMMON的段内。
例子：
        .bss { *(.bss) *(COMMON) }
       这个例子中将所有输入文件的所有通用符号放入输出.bss 段内。可以看到COMMOM 段的使用方法跟其他段的使用方法是一样的。
        有些目标文件格式具有多于一个的普通符号。 比如， MIPS ELF 目标文件格式区分标准普通符号和小普通符号。   

1）、在 MIPS ELF 的情况中， 连接器为标准普通符号使用COMMON， 并且为小普通符号使用.common。这就允许你把不同类型的普通符号映射到内存的不同位置。

2）、在一些老的连接脚本上，你有时会看到[COMMON]。这个符号现在已经过时了， 它等效于*(COMMON)，不建议继续使用这种陈旧的方式。 

（5）输入段和垃圾回收：
      在连接命令行内使用了选项 --gc-sections后，连接器可能将某些它认为没用的段过滤掉，此时就有必要强制连接器保留一些特定的段，可用KEEP()关键字达此目的。如KEEP(*(.text))或KEEP(SORT(*)(.text))
最后看个简单的输入段相关例子：

1.   SECTIONS {
2.   outputa 0×10000 :
3.   {
4.   all.o
5.   foo.o (.input1)
6.   }
7.   outputb :
8.   {
9.   foo.o (.input2)
10.   foo1.o (.input1)
11.   }
12.   outputc :
13.   {
14.   *(.input1)
15.   *(.input2)
16.   }
17.   }

它告诉连接器去读取文件'all.o'中的所有段，并把它们放到输出段

'outputa'的开始位置处， 该输出段是从位置'0x10000'处开始的。

从文件'foo.o'中来的所有段'.input1'在同一个输出段中紧密排列。

从文件'foo.o'中来的所有段'.input2'全部放入到输出段'outputb'中， 后面跟上从'foo1.o'中来的段'.input1'。

来自所有文件的所有余下的'.input1'和'.input2'节被写入到输出段'outputc'中。

（6）在输出段存放数据命令：
能够显示地在输出段内填入你想要填入的信息(这样是不是可以自己通过连接脚本写程序？当然是简单的程序)。
BYTE(EXPRESSION) 1 字节
SHORT(EXPRESSION) 2 字节
LOGN(EXPRESSION) 4 字节
QUAD(EXPRESSION) 8 字节
SQUAD(EXPRESSION) 64位处理器的代码时，8 字节

     输出文件的字节顺序big endianness 或little endianness，可以由输出目标文件的格式决定；如果输出目标文件的格式不能决定字节顺序，那么字节顺序与第一个输入文件的字节顺序相同。

    当使用 64 位系统时，‘QUAD’和‘SQUAD’是相同的；它们都会存储 8 字段，或者说是 64 位的值。而如果软硬件系统都是 32 位的，一个表达式就会被作为 32 位计算。在这种情况下，‘QUAD’存储一个 32 位值，并把它零扩展到 64 位， 而‘SQUAD’会把 32 位值符号扩展到 64 位。

如：BYTE(1)、LANG(addr)。
注意，这些命令只能放在输出段描述内，其他地方不行。
错误：SECTIONS { .text : { *(.text) }  LONG(1)      .data : { *(.data) } }
正确：SECTIONS { .text : { *(.text)  LONG(1) }      .data : { *(.data) } }

     在当前输出段内可能存在未描述的存储区域(比如由于对齐造成的空隙)，可以用FILL(EXPRESSION)命令决定这些存储区域的内容， EXPRESSION的前两字节有效，这两字节在必要时可以重复被使用以填充这类存储区域。如FILE(0×9090)。在输出段描述中可以有=FILEEXP属性，它的作用如同FILE()命令，但是FILE命令只作用于该FILE指令之后的段区域，而=FILEEXP属性作用于整个输出段区域，且FILE命令的优先级更高！！！

这个例子显示如何在未被指定的内存区域填充'0x90'：

FILL(0x90909090)

（7）输出段内命令的关键字：

有两个关键字作为输出段命令的形式出现：

CREATE_OBJECT_SYMBOLS ：为每个输入文件建立一个符号，符号名为输入文件的名字。每个符号所在的段就是’CREATE_OBJECT_SYMBOLS'命令出现的那个段。

 CONSTRUCTORS ：与c++内的(全局对象的)构造函数和(全局对像的)析构函数相关，下面将它们简称为全局构造和全局析构。
对于a.out目标文件格式，连接器用一些不寻常的方法实现c++的全局构造和全局析构。当连接器生成的目标文件格式不支持任意段名字时，比如说ECOFF、XCOFF格式，连接器将通过名字来识别全局构造和全局析构，对于这些文件格式，连接器把与全局构造和全局析构的相关信息放入出现 CONSTRUCTORS关键字的输出段内。
符号__CTORS_LIST__表示全局构造信息的的开始处，__CTORS_END__表示全局构造信息的结束处。
符号__DTORS_LIST__表示全局构造信息的的开始处，__DTORS_END__表示全局构造信息的结束处。
这两块信息的开始处是一字长的信息，表示该块信息有多少项数据，然后以值为零的一字长数据结束。
一般来说，GNU C++在函数__main内安排全局构造代码的运行，而__main函数被初始化代码(在main函数调用之前执行)调用。是不是对于某些目标文件格式才这样？？？
对于支持任意段名的目标文件格式，比如COFF、ELF格式，GNU C++将全局构造和全局析构信息分别放入.ctors 段和.dtors 段内，然后在连接脚本内加入如下，

1.   __CTOR_LIST__ = .;
2.   LONG((__CTOR_END__ – __CTOR_LIST__) / 4 – 2)
3.   *(.ctors)
4.   LONG(0)
5.   __CTOR_END__ = .;
6.   __DTOR_LIST__ = .;
7.   LONG((__DTOR_END__ – __DTOR_LIST__) / 4 – 2)
8.   *(.dtors)
9.   LONG(0)
10.   __DTOR_END__ = .;

如果使用GNU C++提供的初始化优先级支持(它能控制每个全局构造函数调用的先后顺序)，那么请在连接脚本内把CONSTRUCTORS替换成SORT (CONSTRUCTS)，把*(.ctors)换成*(SORT(.ctors))，把*(.dtors)换成*(SORT(.dtors))。一般来说，默认的连接脚本已作好的这些工作。

（8）输出段的丢弃：

1）连接器不会创建那些不含有任何内容的输出段。 这是为了引用那些可能出现或不出现在任何输入文件中的输入段时方便。比如：

.foo { *(.foo) }

如果至少在一个输入文件中有'.foo'段，它才会在输出文件中创建一个'.foo'段

如果你使用了其它的而不是一个输入段描述作为一个输出段命令， 比如一个符号赋值， 那这个输出段总是被创建，即使没有匹配的输入段也会被创建。

2）一个特殊的输出段名`/DISCARD/'可以被用来丢弃输入段。

任何被分配到名为`/DISCARD/'的输出段中的输入段不包含在输出文件中。

（9）输出段属性：
我们再回顾以下输出段描述的文法：
SECTION [ADDRESS] [(TYPE)] : [AT(LMA)]
{
OUTPUT-SECTION-COMMAND
OUTPUT-SECTION-COMMAND
…
} [>REGION] [AT>LMA_REGION] [:PHDR  HDR...] [=FILLEXP]
前面我们浏览了SECTION、ADDRESS、OUTPUT-SECTION-COMMAND相关信息，下面我们将浏览其他属性。

• TYPE ：

  每个输出段都有一个类型，如果没有指定TYPE类型，那么连接器根据输出段引用的输入段的类型设置该输出段的类型。它可以为以下五种值，

        NOLOAD ：该段在程序运行时，不被载入内存。
        DSECT,COPY,INFO,OVERLAY ：这些类型很少被使用，为了向后兼容才被保留下来。这种类型的段必须被标记为“不可加载的”，以便在程序运行不为它们分配内存。如.bss段

• 输出段的LMA ：

默认情况下，LMA等于VMA，但可以通过关键字AT()指定LMA。
用关键字AT()指定，括号内包含表达式，表达式的值用于设置LMA。如果不用AT()关键字，那么可用AT>LMA_REGION表达式设置指定该段加载地址的范围。
这个属性主要用于构件ROM境象。

下面的连接脚本创建了三个输出段：

一个叫做‘.text’从地址‘0x1000’处开始，

一个叫‘.mdata’，尽管它的 VMA 是'0x2000'，它会被载入到'.text'段的后面，

最后一个叫做‘.bss’是用来放置未初始化的数据的，其地址从'0x3000'处开始。

符号'_data'被定义为值'0x2000', 它表示定位计数器的值是 VMA 的值，而不是 LMA。

例：

1.   SECTIONS
2.   {
3.   .text   0×1000 : { *(.text) _etext = . ; }
4.   .mdata 0×2000 : AT ( ADDR (.text) + SIZEOF (.text) )
5.   { _data = . ; *(.data); _edata = . ; }
6.   .bss 0×3000 :
7.   { _bstart = . ; *(.bss) *(COMMON) ; _bend = . ;}
8.   }

这个连接脚本产生的程序使用的运行时初始化代码会包含象下面所示的一些东西，以把初始化后的数据从ROM 映像中拷贝到它的运行时地址中去。注意这段代码是如何利用好连接脚本定义的符号的。

1.   程序如下：
2.   extern char _etext, _data, _edata, _bstart, _bend;
3.   char *src = &_etext;
4.   char *dst = &_data;
5.    
6.   /* ROM has data at end of text; copy it. */
7.   while (dst < &_edata) {
8.   *dst++ = *src++;
9.   }
10.    
11.   /* Zero bss */
12.   for (dst = &_bstart; dst< &_bend; dst++)
13.   *dst = 0;

• 输出段区域：

可以将输出段放入预先定义的内存区域内，例子，
MEMORY { rom : ORIGIN = 0×1000, LENGTH = 0×1000 }
SECTIONS { ROM : { *(.text) } >rom }

• 输出段所在的程序段：

可以将输出段放入预先定义的程序段(program segment)内。如果某个输出段设置了它所在的一个或多个程序段，那么接下来定义的输出段的默认程序段与该输出 段的相同。除非再次显示地指定。例子，
PHDRS { text  PT_LOAD ; }
SECTIONS { .text : { *(.text) } :text }
可以通过:NONE指定连接器不把该段放入任何程序段内。详情请查看PHDRS命令

• 输出段的填充模版：

这个在前面提到过，任何输出段描述内的未指定的内存区域（比如，因为输入段的对齐要求而产生的裂缝），连接器用该模版填充该区域。用法：=FILEEXP，前两字节有效，当区域大于两字节时，重复使用这两字节以将其填满。例子，
SECTIONS { .text : { *(.text) } =0×9090 }（10）覆盖图(overlay)描述：
     覆盖图描述使两个或多个不同的段占用同一块程序地址空间。覆盖图管理代码负责将段的拷入和拷出。考虑这种情况，当某存储块的访问速度比其他存储块要快时，那么如果将段拷到该存储块来执行或访问，那么速度将会有所提高，覆盖图描述就很适合这种情形。文法如下，

1.   SECTIONS {
2.   …
3.    
4.   OVERLAY [START] : [NOCROSSREFS] [AT ( LDADDR )]
5.   {
6.           SECNAME1
7.           {
8.           OUTPUT-SECTION-COMMAND
9.           OUTPUT-SECTION-COMMAND
10.           …
11.           } [:PHDR...] [=FILL]    
12.    
13.           SECNAME2
14.           {
15.           OUTPUT-SECTION-COMMAND
16.           OUTPUT-SECTION-COMMAND
17.           …
18.           } [:PHDR...] [=FILL]
19.           …
20.   } [>REGION] [:PHDR...] [=FILL]
21.    
22.   …
23.   }

由以上文法可以看出，同一覆盖图内的段具有相同的VMA。SECNAME2的LMA为SECTNAME1的LMA加上SECNAME1的大小，同理计算SECNAME2,3,4…的LMA。SECNAME1的LMA由LDADDR决定，如果它没有被指定，那么由START决定，如果它也没有被指定，那么由当前定位符号的值决定。

在 OVERLAY’结构中的段定义跟通常的‘SECTIONS’结构中的段定义是完全相同的，除了一点，就是在‘OVERLAY’中没有地址跟内存区域的定义。NOCROSSREFS关键字指定各段之间不能交叉引用，否则报错。
对于OVERLAY描述的每个段，连接器将定义两个符号__load_start_SECNAME和__load_stop_SECNAME，这两个符号的值分别代表SECNAME 段的LMA地址的开始和结束。
连接器处理完OVERLAY描述语句后，将定位符号的值加上所有覆盖图内段大小的最大值。
看个例子吧，

1.   SECTIONS{
2.   …
3.    
4.       OVERLAY 0×1000 : AT (0×4000)
5.       {
6.           .text0 { o1/*.o(.text) }
7.           .text1 { o2/*.o(.text) }
8.       }
9.   …
10.   }
11.    
12.   .text0 段和.text1 段的VMA地址是0×1000，.text0 段加载于地址0×4000，.text1 段紧跟在其后。
13.   程序代码，拷贝.text1 段代码，
14.   extern char __load_start_text1, __load_stop_text1;
15.   memcpy ((char *) 0×1000, &__load_start_text1,
16.   &__load_stop_text1 – &__load_start_text1);

 

8. 内存区域命令

注意：以下存储区域指的是在程序地址空间内的。
在默认情形下，连接器可以为段分配任意位置的存储区域。你也可以用MEMORY命令定义存储区域，并通过输出段描述的> REGION属性显示地将该输出段限定于某块存储区域，当存储区域大小不能满足要求时，连接器会报告该错误。

MEMORY命令的文法如下，
MEMORY {
NAME1 [(ATTR)] : ORIGIN = ORIGIN1, LENGTH = LEN2
NAME2 [(ATTR)] : ORIGIN = ORIGIN2, LENGTH = LEN2
…
}
NAME ：存储区域的名字，这个名字可以与符号名、文件名、段名重复，因为它处于一个独立的名字空间。
ATTR ：定义该存储区域的属性，在讲述SECTIONS命令时提到，当某输入段没有在SECTIONS命令内引用时，连接器会把该输入 段直接拷贝成输出段，然后将该输出段放入内存区域内。如果设置了内存区域设置了ATTR属性，那么该区域只接受满足该属性的段(怎么判断该段是否满足？输出段描述内好象没有记录该段的读写执行属性)。ATTR属性内可以出现以下7个字符，
R     只读段
W    读/写段
X     可执行段
A     可分配的’段
I       初始化了的段
L      同I
!      不满足该字符之后的任何一个属性的段

ORIGIN ：关键字，区域的开始地址，可简写成org或o
LENGTH ：关键字，区域的大小，可简写成len或l

1.   例：
2.   MEMORY
3.   {
4.   rom (rx) : ORIGIN = 0, LENGTH = 256K
5.   ram (!rx) : org = 0×40000000, l = 4M
6.   }
7.    
8.   SECTIONS { ROM : { *(.text) } >rom } 

此例中，把在SECTIONS命令内*未*引用的且具有读属性或写属性的输入段放入rom区域内，把其他未引用的输入段放入 ram。如果某输出段要被放入某内存区域内，而该输出段又没有指明ADDRESS属性，那么连接器将该输出段放在该区域内下一个能使用位置。

9. PHDRS命令

该命令仅在产生ELF目标文件时有效。
ELF目标文件格式用program headers程序头(程序头内包含一个或多个segment程序段描述)来描述程序如何被载入内存。可以用objdump -p命令查看。
当在本地ELF系统运行ELF目标文件格式的程序时，系统加载器通过读取程序头信息以知道如何将程序加载到内存。要了解系统加载器如何解析程序头，请参考ELF ABI文档。
在连接脚本内不指定PHDRS命令时，连接器能够很好的创建程序头，但是有时需要更精确的描述程序头，那么PAHDRS命令就派上用场了。
注意：一旦在连接脚本内使用了PHDRS命令，那么连接器**仅会**创建PHDRS命令指定的信息，所以使用时须谨慎。
PHDRS命令文法如下，
PHDRS
{
NAME TYPE [ FILEHDR ] [ PHDRS ] [ AT ( ADDRESS ) ]
[ FLAGS ( FLAGS ) ] ;
}
其中FILEHDR、PHDRS、AT、FLAGS为关键字。
NAME ：为程序段名，此名字可以与符号名、段名、文件名重复，因为它在一个独立的名字空间内。此名字只能在SECTIONS命令内使用。
一个程序段可以由多个‘可加载’的段组成。通过输出段描述的属性:PHDRS可以将输出段加入一个程序段，: PHDRS中的PHDRS为程序段名。在一个输出段描述内可以多次使用:PHDRS命令，也即可以将一个段加入多个程序段。
如果在一个输出段描述内指定了:PHDRS属性，那么其后的输出段描述将默认使用该属性，除非它也定义了:PHDRS属性。显然当多个输出段属于同一程序段时可简化书写。
在TYPE属性后存在FILEHDR关键字，表示该段包含ELF文件头信息；存在PHDRS关键字，表示该段包含ELF程序头信息。
TYPE可以是以下八种形式，
PT_NULL 0
表示未被使用的程序段
PT_LOAD 1
表示该程序段在程序运行时应该被加载
PT_DYNAMIC 2
表示该程序段包含动态连接信息
PT_INTERP 3
表示该程序段内包含程序加载器的名字，在linux下常见的程序加载器是ld-linux.so.2
PT_NOTE 4
表示该程序段内包含程序的说明信息
PT_SHLIB 5
一个保留的程序头类型，没有在ELF ABI文档内定义
PT_PHDR 6
表示该程序段包含程序头信息。
EXPRESSION 表达式值
以上每个类型都对应一个数字，该表达式定义一个用户自定的程序头。
AT(ADDRESS)属性定义该程序段的加载位置(LMA)，该属性将**覆盖**该程序段内的段的AT()属性。
默认情况下，连接器会根据该程序段包含的段的属性(什么属性？好象在输出段描述内没有看到)设置FLAGS标志，该标志用于设置程序段描述的p_flags域。
下面看一个典型的PHDRS设置，

1.   PHDRS
2.   {
3.   headers PT_PHDR PHDRS ;
4.   interp PT_INTERP ;
5.   text PT_LOAD FILEHDR PHDRS ;
6.   data PT_LOAD ;
7.   dynamic PT_DYNAMIC ;
8.   }
9.   SECTIONS
10.   {
11.   . = SIZEOF_HEADERS;
12.   .interp : { *(.interp) } :text :interp
13.   .text : { *(.text) } :text
14.   .rodata : { *(.rodata) } /* defaults to :text */
15.   …
16.   . = . + 0×1000; /* move to a new page in memory */
17.   .data : { *(.data) } :data
18.   .dynamic : { *(.dynamic) } :data :dynamic
19.   …
20.   }

10. 版本号命令

当使用ELF目标文件格式时，连接器支持带版本号的符号。
读者可以发现仅仅在共享库中，符号的版本号属性才有意义。
动态加载器使用符号的版本号为应用程序选择共享库内的一个函数的特定实现版本。
可以在连接脚本内直接使用版本号命令，也可以将版本号命令实现于一个特定版本号描述文件(用连接选项–version-script指定该文件)。
该命令的文法如下，

1.   VERSION { version-script-commands }
2.   以下内容直接拷贝于以前的文档，
3.   ===================== 开始 ==================================
4.   内容简介
5.   ———
6.   0 前提
7.   1 带版本号的符号的定义
8.   2 连接到带版本的符号
9.   3 GNU扩充
10.   4 我的疑问
11.   5 英文搜索关键字
12.   6 我的参考
13.    
14.   0. 前提
15.    
16.   – 只限于ELF文件格式
17.   – 以下讨论用gcc
18.    
19.   1. 带版本号的符号的定义(共享库内)
20.    
21.   文件b.c内容如下，
22.   int old_true()
23.   {
24.   return 1;
25.   }
26.    
27.   int new_true()
28.   {
29.   return 2;
30.   }
31.    
32.   写连接器的版本控制脚本，本例中为b.lds，内容如下
33.   VER1.0{
34.   new_true;
35.   };
36.   VER2.0{
37.   };
38.    
39.   $gcc -c b.c
40.   $gcc -shared -Wl,–version-script=b.lds -o libb.so b.o
41.    
42.   可以在{}内填入要绑定的符号，本例中new_true符号就与VER1.0绑定了。
43.   那么如果有一个应用程序连接到该库的new_true符号，那么它连接的就是VER1.0版本的new_true符号
44.    
45.   如果把b.lds更改为，
46.   VER1.0{
47.   };
48.   VER2.0{
49.   new_true;
50.   };
51.    
52.   然后在生成libb.so文件，在运行那个连接到VER1.0版本的new_true符号的应用程序，可以发现该应用程序不能运行了，
53.   因为库内没有VER1.0版本的new_true，只有VER2.0版本的new_true。
54.    
55.   2. 连接到带版本的符号
56.   写一个简单的应用(名为app)连接到libb.so，应用符号new_true
57.   假设libb.so的版本控制文件为，
58.   VER1.0{
59.   };
60.   VER2.0{
61.   new_true;
62.   };
63.    
64.   $ nm app | grep new_true
65.   U new_true@@VER1.0
66.   $
67.   用nm命令发现app连接到VER1.0版本的new_true
68.    
69.   3. GNU的扩充
70.   它允许在程序文件内绑定 *符号* 到 *带版本号的别名符号*
71.    
72.   文件b.c内容如下，
73.   int old_true()
74.   {
75.   return 1;
76.   }
77.    
78.   int new_true()
79.   {
80.   return 2;
81.   }
82.   __asm__( “.symver old_true,[email protected]″ );
83.   __asm__( “.symver new_true,true@@VER2.0″ );
84.    
85.   其中，带版本号的别名符号是true，其默认的版本号为VER2.0
86.    
87.   供连接器用的版本控制脚本b.lds内容如下，
88.   VER1.0{
89.   };
90.   VER2.0{
91.   };
92.    
93.   版本控制文件内必须包含版本VER1.0和版本VER2.0的定义，因为在b.c文件内有对他们的引用
94.    
95.   ****** 假定libb.so与app.c在同一目录下 ********
96.    
97.   以下应用程序app.c连接到该库，
98.   int true();
99.   int main()
100.   {
101.   printf( “%d “, true );
102.   }
103.    
104.   $ gcc app.c libb.so
105.   $ LD_LIBRARY_PATH=. ./app
106.   2
107.   $ nm app | grep true
108.   U true@@VER2.0
109.   $
110.    
111.   很明显，程序app使用的是VER2.0版本的别名符号true，如果在b.c内没有指明别名符号true的默认版本，
112.   那么gcc app.c libb.so将出现连接错误，提示true没有定义。
113.    
114.   也可以在程序内指定特定版本的别名符号true，程序如下，
115.   __asm__( “.symver true,[email protected]″ );
116.   int true();
117.   int main()
118.   {
119.   printf( “%d “, true );
120.   }
121.    
122.   $ gcc app.c libb.so
123.   $ LD_LIBRARY_PATH=. ./app
124.   1
125.   $ nm app | grep true
126.   U [email protected]
127.   $
128.    
129.   显然，连接到了版本号为VER1.0的别名符号true。其中只有一个@表示，该版本不是默认的版本
130.    
131.   我的疑问：
132.   版本控制脚本文件中，各版本号节点之间的依赖关系
133.    
134.   英文搜索关键字：
135.   .symver
136.   versioned symbol
137.   version a shared library
138.    
139.   参考：
140.   info ld, Scripts node
141.   ===================== 结束 ==================================

11. 表达式

表达式的文法与C语言的表达式文法一致，表达式的值都是整型，如果ld的运行主机和生成文件的目标机都是32位，则表达式是32位数据，否则是64位数据。
能够在表达式内使用符号的值，设置符号的值。
下面看六项表达式相关内容，

另外，你可以使用'K'和'M'后缀作为常数的度量单位，下面的三个常数表示同一个值。

_fourk_1 = 4K;

_fourk_2 = 4096;

_fourk_3 = 0x1000;

常表达式：
_fourk_1 = 4K; /* K、M单位 */
_fourk_2 = 4096; /* 整数 */
_fourk_3 = 0×1000; /* 16 进位 */
_fourk_4 = 01000; /* 8 进位 */

• 符号名：

没有被引号”"包围的符号，以字母、下划线或’.'开头，可包含字母、下划线、’.'和’-'。

当符号名被引号包围时，符号名可以与关键字相同。如：
“SECTION”=9
“with a space” = “also with a space” + 10;

• 定位符号’.'：

只在SECTIONS命令内有效，代表一个程序地址空间内的地址。
注意：当定位符用在SECTIONS命令的输出段描述内时，它代表的是该段的当前**偏移**，而不是程序地址空间的绝对地址。
先看个例子，

1.   SECTIONS
2.   {
3.   output :
4.   {
5.   file1(.text)
6.   . = . + 1000;
7.   file2(.text)
8.   . += 1000;
9.   file3(.text)
10.   } = 0×1234;
11.   }
12.   其中由于对定位符的赋值而产生的空隙由0×1234填充。其他的内容应该容易理解吧。
13.   再看个例子，
14.   SECTIONS
15.   {
16.       . = 0×100
17.       .text: {
18.                   *(.text)
19.                   . = 0×200
20.       }
21.       . = 0×500
22.       .data: {
23.               *(.data)
24.               . += 0×600
25.       }
26.   } 

.text 段在程序地址空间的开始位置是0x100，.text段的结束地址不是绝对地址0x200，而是相对.text段的结束地址再加上0x200。

• 表达式的操作符：

与C语言一致。
优先级 结合顺序 操作符
1 left ! – ~ (1)
2 left * / %
3 left + -
4 left >> <<
5 left == != > < <= >=
6 left &
7 left |
8 left &&
9 left ||
10 right ? :
11 right &= += -= *= /= (2)
(1)表示前缀符，(2)表示赋值符。

• 表达式的计算：

连接器延迟计算大部分表达式的值。
但是，对待与连接过程紧密相关的表达式，连接器会立即计算表达式，如果不能计算则报错。比如，对于段的VMA地址、内存区域块的开始地址和大小，与其相关的表达式应该立即被计算。
例子，
SECTIONS
{
    .text 9+this_isnt_constant :
    { *(.text) }
}
这个例子中，9+this_isnt_constant表达式的值用于设置.text 段的VMA地址，因此需要立即运算，但是由于this_isnt_constant变量的值不确定，所以此时连接器无法确立表达式的值，此时连接器会报错。

• 相对值与绝对值：

1、在输出段描述内的表达式，连接器取其相对值，相对与该段的开始位置的偏移
2、在SECTIONS命令内且非输出段描述内的表达式，连接器取其绝对值
通过ABSOLUTE关键字可以将相对值转化成绝对值，即在原来值的基础上加上表达式所在段的VMA值。
例子，
SECTIONS
{
.data : { *(.data)    _edata = ABSOLUTE（.）; }
}
该例子中，_edata符号的值是.data 段的末尾位置(绝对值，在程序地址空间内)。

• 内建函数：

1.   ABSOLUTE(EXP) ：把EXP转换成绝对值
2.   ADDR(SECTION) ： 返回某段的VMA值。你的脚本之前必须已经定义了这个段的地址，如ADDR(.text)，返回.text段的地址
3.   ALIGN(EXP) ：          返回定位计数器'.'对齐到下一个EXP 指定的边界后的值。‘ALIGN’不改变定位计数器的值，它只是在定位计数器上面作了一个算术运算。
4.    
5.   BLOCK(EXP) ：            如同ALIGN(EXP)，为了向前兼容。
6.   DEFINED(SYMBOL) ：如果符号SYMBOL在全局符号表内，且被定义了，那么返回1，否则返回0。例子，
7.   SECTIONS { …
8.   .text : {
9.   begin = DEFINED(begin) ? begin : .  ;
10.   …
11.   }
12.   …
13.   }
14.    
15.   LOADADDR(SECTION) ： 返回SECTION的LMA
16.   MAX(EXP1,EXP2) ： 返回大者
17.   MIN(EXP1,EXP2) ：   返回小者
18.   NEXT(EXP) ：             返回下一个能被使用的地址，该地址是EXP的倍数，类似于ALIGN(EXP)。除非使用了MEMORY命令定义了一些非连续的内存块，否则NEXT(EXP)与ALIGH(EXP)一定相同。
19.   SIZEOF(SECTION) ：返回SECTION的大小。当SECTION没有被分配时，即此时SECTION的大小还不能确定时，连接器会报错。
20.   SIZEOF_HEADERS ：
21.   sizeof_headers ：返回输出文件的文件头大小(还是程序头大小)，用以确定第一个段的开始地址(在文件内)。

12. 暗含的连接脚本
输入文件可以是目标文件，也可以是连接脚本，此时的连接脚本被称为 暗含的连接脚本
如果连接器不认识某个输入文件，那么该文件被当作连接脚本被解析。更进一步，如果发现它的格式又不是连接脚本的格式，那么连接器报错。
一个暗含的连接脚本不会替换默认的连接脚本，仅仅是增加新的连接而已。
一般来说，暗含的连接脚本符号分配命令，或INPUT、GROUP、VERSION命令。
在连接命令行中，每个输入文件的顺序都被固定好了，暗含的连接脚本在连接命令行内占住一个位置，这个位置决定了由该连接脚本指定的输入文件在连接过程中的顺序。
典型的暗含的连接脚本是libc.so文件，在GNU/linux内一般存在/usr/lib目录下。

 References

1, gnu ld 在线手册

2, 程序的链接和装入及 Linux 下动态链接的实现

3, UNIX/Linux 平台可执行文件格式分析

4, John R. Levine.《Linkers & Loaders》
转自 https://blog.csdn.net/han22647/article/details/64920623

二 链接脚本分析1

以u-boot.lds为例，位于根文件夹下/board/samsung/x210内，它是U-boot的总链接脚本。

• 本段最开始指定了输出的格式，然后指定输出的架构为arm架构
• 指定整个程序的入口地址，可以认为是第一句指令，_start是start.S的第一个lable
• 值得注意的是，程序入口并不代表它位于存储介质的起始位置。一般起始位置存放的是16字节校验头和异常向量表

1.   OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm")
2.   /*OUTPUT_FORMAT("elf32-arm", "elf32-arm", "elf32-arm")*//*这句是注释*/
3.   OUTPUT_ARCH(arm)
4.   ENTRY(_start)

• SECTIONS表示正式开始地址划分
• .的意思是当前地址，这句将当前地址（代码段起始地址）设为0x00000000，但是其实这个地址会被config.mk用-Ttext $(TEXT_BASE)指定的虚拟地址0xc3e00000（由顶层Makefile填充给config.mk）覆盖掉

1.   SECTIONS
2.   {
3.   . = 0x00000000;
4.    
5.   . = ALIGN(4);
6.   .text :

• .text表示开始代码段的链接
• 代码段的链接顺序很重要，首先start.o必须在第一个
• 由于uboot需要重定位，故所有和重定位有关的代码必须链接在最前面，作为16kb的bl1。而其他所有的.o文件就往后任意链接了

1.   .text :
2.   {
3.   cpu/s5pc11x/start.o (.text)
4.   cpu/s5pc11x/s5pc110/cpu_init.o (.text)
5.   board/samsung/x210/lowlevel_init.o (.text)
6.   cpu/s5pc11x/onenand_cp.o (.text)
7.   cpu/s5pc11x/nand_cp.o (.text)
8.   cpu/s5pc11x/movi.o (.text)
9.   common/secure_boot.o (.text)
10.   common/ace_sha1.o (.text)
11.   cpu/s5pc11x/pmic.o (.text)
12.   *(.text)
13.   }

• . = ALIGN(4)的意思是将当前地址（代码段结束地址）四字节对齐，然后将其作为只读数据段的起始地址（存放只读的全局变量）
• 同理，对数据段（存放全局变量）和got段进行相同设置

1.   . = ALIGN(4);
2.   .rodata : { *(.rodata) }
3.    
4.   . = ALIGN(4);
5.   .data : { *(.data) }
6.    
7.   . = ALIGN(4);
8.   .got : { *(.got) }
9.    

• 设置自定义段u_boot_cmd，里面存放着的是一个个命令结构体（结构体内都是命令的信息），它们是紧挨着的，其实有点像结构体数组，只不过是乱序的。写出 __u_boot_cmd_start， __u_boot_cmd_endt的地址是为了要在源码中引用这两个地址，由此来使用命令结构体
• 然后设置mmudata段
• 最后设置bss段（存放初始值为0的全局变量），写出 __bss_start，_end就是为了要在.s或.c中引用这两个地址
• 1.   __u_boot_cmd_start = .;
  2.   .u_boot_cmd : { *(.u_boot_cmd) }
  3.   __u_boot_cmd_end = .;
  4.    
  5.   . = ALIGN(4);
  6.   .mmudata : { *(.mmudata) }
  7.    
  8.   . = ALIGN(4);
  9.   __bss_start = .;
  10.   .bss : { *(.bss) }
  11.   _end = .;
  12.   }

三 链接脚本分析2

 

链接三要素：链接顺序，链接地址，加载地址

1.连接顺序的问题

　　倘若没有链接脚本，例如：arm-linux-ld –Ttext 0x00000000 -o nand_elf ，那么链接顺序就是，那么链接顺序就是^的顺序，即makefile中依赖的顺序。

　　倘若有链接脚本，则会按照链接脚本的规则进行链接。例如：

1.   SECTIONS { 
2.     firtst   0x00000000 : {head.o init.o nand.o}
3.     second  x30000000 : AT(4096){ main.o}
4.   } 

这个规则中定义了两个大段，first和second。
first的链接顺序为head.o init.o nand.o. Second的链接顺序为main.o。

2.链接地址的问题

　　先说明一下链接地址的概念，链接地址是程序实际运行的地址。通常程序中有位置无关代码和位置有关代码。位置无关代码是对于链接地址无要求，可以在不是它链接地址的地方运行；但是位置有关代码，必须在链接地址运行。也就是说当运行位置有关代码时，程序必须事先在链接地址上，如果没有在，通常需要COPY到那个位置或者利用MMU映射一下。

　　下边以一个例子来说明一下链接脚本中链接地址的问题。

1.    SECTIONS { 
2.     firtst   0x00000000 : {head.o}
3.     second 0x00000200 : AT(300) {init.o}
4.     third  0x00000400 : AT(500) {nand.o}
5.     fourth  0x30000000 : AT(3096) { main.o}
6.   } 

四个部分：first、second、third、foutth，它们的链接地址分别是0x00000000、0x00000200、0x00000400、0x30000000。

3.加载地址

　　加载地址指的是程序编译后的存放地址，通常存放在ROM、FLASH中，所以就是指这段程序在ROM、FLASH中的存放位置。还是以上边的连接脚本为例。

1.    SECTIONS { 
2.     firtst   0x00000000 : {head.o}
3.     second 0x00000200 : AT(300) {init.o}
4.     third  0x00000400 : AT(500) {nand.o}
5.     fourth  0x30000000 : AT(3096) { main.o}
6.   }

它们的存放地址分别是0、300、500、3096。

转至https://www.cnblogs.com/amanlikethis/p/3344519.html

四  段名

说明

1

.text

存放程序运行代码（机器码）

2

.data

存放了经过初始化的全局变量和静态变量

3

.bss

保存了那些用到但未被初始化的数据

4

.rodata

只读数据段

5

.shstrtab

段名字符串表

6

.symtab

保存了连接时所需的符号信息

7

.strtab

保存了.symtab所需的符号信息。

8

.init

C++编译器生成的用来实现全局构造；该段自动产生名为init的函数，该函数早于main执行

9

.fini

同.init都为实现全局构造；该段自动产生名为fini的函数，该函数在main函数结束之后执行

10

.comment

包含编译器版本信息，不重要

11

.debug

保存调试相关信息，如.debug_info  .debug_line等

12

.dynstr

保存动态链接符号字符串名

13

.dynsym

保存动态链接符号

14

.fini_array

保存程序或共享对象退出时的退出函数地址

15

.hash

哈希表

16

.init_array

保存程序或共享对象加载时的初始化函数指针

17

.interp

动态链接库路径

18

.line

调试时行号信息

19

.note

额外信息，与平台相关

20

.preinit_array

同init_array  但早于init_array执行

21

.tbss

线程的未初始化数据

22

.tdata

线程的初始化数据

23

.ctors

保存全局构造函数指针

24

.data.rel.ro

类似.rodata

25

.dtors

保存了全局析构函数指针

26

eh_frame

C++异常处理内容

27

.eh_frame_hdr

同eh_frame

28

.got.plt

保存动态链接的延迟绑定相关信息

29

.jcr

Java语言相关信息

30

.note.ABI-tag

保存程序ABI信息

31

.stab

调试信息

32

.stabstr

.stab中包含的字符串信息

 

 

标签：输出,文件,text,符号,链接,地址,详解,data,ARM
From： https://www.cnblogs.com/zxdplay/p/17974236