链接脚本

kenson

0 u: K2 h9 h( m 摘要：     什么是链接脚本，就是用于告诉链接器如何把输入文件内的各个段（section）放到输出文件中，并控制输出文件中的各个段在此程序运行时的地址空间布局。一个程序由多个段组成，那么这些段是如何在文件中存放的，以及是如何加载到内存的相应位置进行执行的呢，这个就是通过连接脚本进行控制的。链接脚本格式...
3 e' U# s( d6 c0 N
    什么是链接脚本，就是用于告诉链接器如何把输入文件内的各个段（section）放到输出文件中，并控制输出文件中的各个段在此程序运行时的地址空间布局。一个程序由多个段组成，那么这些段是如何在文件中存放的，以及是如何加载到内存的相应位置进行执行的呢，这个就是通过连接脚本进行控制的。
( i7 ~# \4 i8 V# u5 `( {+ o3 b5 x
链接脚本格式：
# }2 k- U/ W% i5 u+ P" {9 Q0 q
    链接脚本由一系列命令组成，每一个命令由一个关键字和相应的参数，或者一些赋值语句等组成。命令由分号进行分割。用/* */进行注释。
" D7 m3 U0 T! t4 z! y& }$ D* [
$ w/ t4 o+ u  }4 \) x常见命令：

    ENTRY（SYMBOL）；将SYMBOL的值设置成入口地址。一般设置为_start。
   
    OUTPUT（FILENAME）；定义输出文件的名字。可以用它来指定默认的输出文件名称。当然我们一般都用手动-o进行指定，如果我们没有进行手动指定的话，输出文件名称就以这个FILENAME为输出文件名。

    STARTUP（filename）；指定filename为第一个输入文件。
1 |" ^( B7 x! Y3 W
    OUTPUT_FORMAT(default, big, little);定义3种输出文件的格式。若有命令行选项－EB（大端），则使用第二个输出格式，有命令行指定－EL（小端），则使用第三个格式。否则使用默认的default输出格式。
* ]) Q/ W0 i, x2 g
% V& f5 R( b, f, v  A& P6 i    OUTPUT_ARCH(arch);设置输出文件的体系架构。


( _4 B! @" J; O! |, `1 J    SECTIONS命令：最重要的，最基本的，也是最主要的命令，它告诉链接器如何把输入文件的各个section输出到目标文件中的各个section中去。
+ x; ]5 K! W5 l& s6 K& i   
        SECTIONS命令的格式如下：

# g$ B0 Y0 |$ f& p4 k2 v& E        SECTIONS
        ｛
                一条或者多条section-command
8 |+ b8 i$ V6 J2 Q& \                或者符号赋值语句
. V2 ^( V. V' D4 t# W0 m        ｝
      
        section-command的常见格式如下：
! Z- ?' ?' _0 Z3 T7 f
        secname [address] : [AT(LMA)]
        { contents }

            首先中括号的选项是可选的，可以不写。
      
            secname, 指定输出的段名称。
            address, 表示程序的VMA地址。也就是表示当执行此程序的时候程序加载器应该把这个段加载到内存的哪个地址。如果没有指定这个地址，链接器根据定位符号‘.‘的值设置该section的VMA。
            AT, 后面跟LMA， 这个是表示当我们把目标文件拷贝成二进制的时候，该段在文件中物理存放位置的偏移。这个可以用来把多个不同的部分的代码写到一个文件中，然后烧写到flash上去，然后，程序在运行的时候再把它从AT指定的位置读到内存的另外一个位置上去。
% k+ y% Z0 G6 C: @9 W
            contents，内容里面指定把哪些文件里面的哪些段或者该文件全部输出到secname所指定的这个段中。比如*(.text)就表示所有输入文件的.text段。括号外面表示文件名称，括号里面表示这些文件里面的什么段。

        例子：
* n7 s; o: G$ s6 N
            SECTIONS ｛
" Q" i; _; [0 {                    . = 0x30000000;         //表示设置当前符号的值为0x3000000
                    .text : { *(.text) }    //表示把所有输入文件的代码段集合在一起，起始运行地址就为当前定位符号的值，-- 0x30000000
" s; _. v) s1 _3 r% j                    .rodata ALIGN(4) : {*(.rodata) }   // 在输出文件中它紧挨着.text段存放。
            ｝
           

7 X' G5 z& n: Y) V常见的例子：

2 Z  N4 `+ G: b* ~9 s（1）：

ENTRY(_start);
. q: D6 k; s" i' }- w! w1 IOUTPUT_FORMAT("elf32-littlearm", "elf32-bigarm","elf32-littlearm");
" A. j- C" @& I) |  f+ E7 g9 a7 U+ tOUTPUT_ARCH(arm);
. @( v: Q1 D/ I. ~% u% S+ N
# A# ?* m1 p9 D. \% `SECTIONS
+ n9 J8 s/ M9 [0 ]: W/ ]{
! ]' J6 T+ r+ }$ g! D1 g2 ~        . = 0x50008000;
9 D  p" J9 B  |. a4 x; G
        . = ALIGN(4);
% k8 p4 n, q& o4 {- N+ j# R6 n$ u        .text : {
, G/ l: R* I* [: g1 U1 L0 N( Z2 _  Z" b                *(.text);
        }

( c/ ~+ u% ?. i3 r2 K. i. R        . = ALIGN(4);
        .rodata : {
                *(.rodata);
        }

$ x! c, d% y$ n! B/ A6 X/ N4 q        . = ALIGN(4);
        .data : {
3 j1 Z! k3 v2 R( w7 ~                *(.data);
3 _" C( B# y8 O% b  |        }
/ @' Z% H5 l$ A
        . = ALIGN(4);
2 f% y2 @6 {& o' v# `        .bss : {
3 e& R' w$ C5 y) x. Q, x% H                *(.bss);
' \( S8 h0 B' o, I        }
0 s+ v1 [6 C7 Y0 R7 E# e}

    这个链接脚本表示代码段从0x30000000开始加载，然后后面的.rodata,.data,.bss段都分别加在其后，并且后面的每个段的起始地址是按照4个字节对齐的。
- K8 E& |1 D2 B  U. Z8 h
9 {, |! |+ f! e7 G（2）：
               
ENTRY(_start);
% e( [' }$ N0 `1 I" m8 @OUTPUT_FORMAT("elf32-littlearm", "elf32-bigarm","elf32-littlearm");
5 Y9 T  M4 t) t* E. g3 k$ P9 ]! BOUTPUT_ARCH(arm);

4 G5 k( ]/ J: USECTIONS
# k4 X( p2 ^" J( l( N$ q{
    start 0x00000000 : { start.o }
  E+ n0 N4 e3 ?- ]5 t    main 0x30000000 : AT(4096) { main.o hello.o }
}
           
, u2 I: h6 K) V+ ^- s5 C! h    上面表示把start.o的运行地址指定为0x000000, 然后main.o hello.o程序的运行地址指定为0x30000000，当我们把链接后生成的可执行文件通过objcopy出来之后，那么start.o的二进制代码就从文件的0偏移开始存放，main.o hello.o就从同一个文件的4096这个位置开始存放。当时main.o hello.o是挨着存放的，并没有把他们的相同段放在同一个段里面。

======================================

% |+ A7 |  Z9 p! T8 w/ kENTRY(_start);
OUTPUT_FORMAT("elf32-littlearm", "elf32-bigarm","elf32-littlearm");
OUTPUT_ARCH(arm);
$ l7 `- c  x3 L) M% J/ ]
SECTIONS
{
        first 0x0 : {
" E4 u" Y9 i( I. P) K5 Q7 v                led.o
        }

        .text 0x30000000 : AT(4096){
! B1 u* t, l6 T, h' h4 t+ ]8 [' X                *(.text);
( z3 P. K: Z( b: K+ X  P        }
9 U, p8 ~5 }& b+ x2 F+ |" c6 e
        .text 0x32000000 : AT(5100){
                a*.o(.text)
) S) D/ @% W1 z) M. d        }
2 _* f; C9 K' S% M: j% H+ O4 z/ }
, X! b" r% s4 C; A& c8 `        .rodata : {
                *(.rodata);
        }

        .data : {
# Q& b3 P2 w" r9 {2 X                *(.data);
        }
) Y3 g2 a" Q, Z6 H* ?6 q, Y
# {( C/ n0 w1 @9 \. J        _bss_start = .;
) }* I) D/ L# c0 E% N        .bss : {
, Y+ `5 R3 _* @/ v% B                *(.bss);
        }
        _bss_end = .;
% n/ x4 y4 R  ^5 B}

    其实secname在copy成binary文件的时候已经没有了，这个只是在有操作系统的情况下才有用。因此在拷贝成二进制的时候，前面的段名称根本不是很重要，只是后面的的地址和在文件中的地址才是最关心的。

    如果我们在SECTIONS内部定义了变量，那么这个相当于在这个位置定义了一个变量，如果我们要取这个变量地址，我们需要在C语言中使用&_bss_start来访问。

kenson

; k& n) E" J. M
链接定位是系统级软件开发过程中必不可少的一部分,嵌入式软件开发均属于系统级开发,绝大部分嵌入式软件都涉及到链接定位脚本文件;链接定位脚本使得我们的目标代码组织更加灵活.
+ g) p7 i7 C0 p0 ]. n6 q
* _7 ?7 p' m7 r: @" s1)链接定位脚本文件说明
& t- X. r& u( Y; [, y/ E; B链接定位过程一般由链接器根据链接定位脚本完成,比较简单的系统可以通过设置链接器开关选项取代链接定位脚本;链接定位的关键是链接定位脚本的编写.我们从典型的目标文件结构开始,来介绍链接定位脚本文件的编写.下面是该系统一个目标文件的典型组织:  



其中第二栏开始分别展示了该文件各个段(Sections)的属性:名称(Name),类型(Type),地址(Addr),偏移(Offs),大小 (Size),固定单元大小(Es),标志(Flg),连接依赖(Lk),附加属性(Inf),字节对其宽度(Al). 地址部分(Addr)描述了这一段在目标系统中的地址,而偏移(Offs)则记载了该段在目标文件中的偏移,大小(size)表示该段的实际长度;比如上 图中.Text段的地址为0x0c700000,偏移为0x008000,大小为0x00d950,说明该段位于文件的偏移0x008000处,它将被下 载到目标板0x0c700000处. 从段的分类来看,第7段以后的内容仅仅与调试有关,涉及到定位的也就是前面几段:.text,.data,.rodata,.bss,下面是一个具体的链 接定位脚本文件:
SECTIONS
/ ?: _" j4 j. C- [2 x- `{
: P$ Z) B; t" C# v( `; [  G& _. = 0x0c200000; /*赋当前地址,后续的代码将从该地址开始存放 */
. w3 o- b3 Z0 I6 ]5 C$ E% i.text : { (.text) } /*.text段表示代码段,从0x0c200000开始放置代码*/

: I3 Y* ]6 @; q0 [- |. XImage_RW_Base = .; /* RW(可写数据)基址,实际上是在这里声明了一个全局符号,我们可
8 H3 X; d# E9 Z以在程序中使用该符号,它等同于在代码中声明一个全局变量,但它的值由链接器指定,在这里"=."表
示该符号的值等于当前地址;下面的定义类似*/

  A7 }+ o9 l: G6 D) L( X.data : { (.data) } /*数据段, 保存已经初始化的全局数据 */
- }9 t! K$ o7 J" \7 v1 j2 ]( d.rodata : { *(.rodata) } /*只读数据段, 保存已经初始化的全局只读数据*/

+ E5 X0 `  {: A; M6 L5 HImage_ZI_Base = .; /*ZI基地址, 需要清零的区域 zero init*/
) ]& i6 E& Y% i0 r" o' ~" H.bss : { *(.bss) } /*堆栈段,未初始化的全局变量也保存在此*/

__bss_start__ = .; /* bss的基地址*/
9 O8 ~7 I" b4 F( X/ R7 h__bss_end__ = .; /* bss的结束地址*/
8 S; a+ U2 h" S& E. l4 D) W' I  Q
__EH_FRAME_BEGIN__ = .; /* FRAME开始地址(基地址)*/
__EH_FRAME_END__ = .; /* FRAME结束地址,gcc编译器使用 */

FAQ
1 c0 R) r! ]; z+ e$ RPROVIDE (__stack = .); /* 当前地址赋给栈,栈地址一般是可读写区最高处*/
8 D. C" ?& P" v: V( n( P! c2 [7 ~
end = .; /* 结束地址*/
8 E' |$ F+ L% m/ N$ V6 O_end = .; /* 结束地址*/

. ^8 S% Y1 _6 {, @- ~5 Y* c.debug_info 0 : { *(.debug_info) } /*调试信息*/
5 v0 N: T# H# h, H7 l. w.debug_line 0 : { *(.debug_line) } /*调试信息*/
; _' t6 n; M+ x7 ^+ r- ~.debug_abbrev 0 : { *(.debug_abbrev)} /*调试信息*/
.debug_frame 0 : { *(.debug_frame) } /*调试信息*/
}
5 p, R4 b7 Z  c$ s1 l* v# `8 atext段是程序代码段,紧随其后的是几个符号定义,它们是由编译器在编译连接时自动计算的,当我们在链接定位文件中申明这些符号后,编译连接时,该符号 的值会自动代入到源程序的引用中,如果你想进一步了解连接定位的一些含义,可以参考编程手册中的ld一章. data段的起始位置也是由连接定位文件所确定,大小在编译连接时自动分配,它和我们的程序大小没有关系,但和程序使用到的全局变量,常量数量相关. bss的初始值也是由我们自己定义的连接定位文件所确定,我们应该将它定义在可读写的RAM区内,stack的顶部在可读写的RAM区的最后,我们可以非 常灵活的定义其起点和大小,但对大部分情况来说,程序区在ROM或FLASH中,可读写区域在SRAM或DRAM中,我们可以考虑一下自己程序规模,函数 调用规模,存储器组织,然后参照一个连接定位文件稍加修改就可以了.

( Y+ ~+ i: m8 ?, g, C6 }: t- b* ~2)链接定位脚本修改实例
5 R5 H' B4 L3 V, p& V  U( LSECTIONS
; @/ j/ s4 `2 s! V% P+ \{
. = 0x00000000; /*将代码段起始地址修改到0*/
+ N* H3 u/ k* q/ X0 W; }2 J* A.text : { *(.text) }
* }, H0 B# p" T) A/ AImage_RW_Base = .;
/ e! W/ p7 ?: r/ K.=0xc0000000 /*设置数据段从0xc0000000开始存放*/
) ~! o4 E3 e% U3 i% P# f.data : { *(.data) }

.=0xd0000000 /*设置只读数据段从0xd0000000开始存放*/
.rodata : { *(.rodata) }
3 F+ A) Y( E; L  F
Image_ZI_Base = .;
% m8 G6 E  e: d9 j.bss : { *(.bss) }
" I' o7 {: _  u  OImage_ZI_Limit = .;

( R( J* a2 T! o/*申明一个符号download_size */
3 P3 i4 r7 |0 ?download_size = SIZEOF(.text)+SIZEOF(.data)+SIZEOF(.rodata)+SIZEOF(.bss);

__bss_start__ = .;
. C0 l, c8 Z. B1 ?__bss_end__ = .;

kenson

Linux链接脚本学习--lds
  u: `* s* b; K5 S" o4 M

0 J9 X2 G; |; Z- u一、概论
0 S# k2 w4 g/ l3 G5 V9 _3 V
# M7 ]! ~- ]! I& f& Q5 ]4 k8 rld:
& p  F6 t/ Z- N0 w9 G
GNU的链接器.
4 L0 D2 |/ Q# n+ H
) ?4 q9 K0 r8 k- D$ V) H用来把一定量的目标文件跟档案文件链接在一起,并重新定位它们的数据,链接符号引用.

一般编译一个程序时,最后一步就是运行ld进行链接
. x/ F- ~' y- v. _0 u1 _3 T
# o2 u8 g. Z- }6 t) X- j" D. ]5 O4 o每一个链接都被一个链接脚本所控制,这个脚本是用链接命令语言书写的.
5 Q0 w" |. R% V' h; }  p$ a9 x
2 `, I  O3 n- z. }: K4 x二、链接脚本

2 m# ^. d6 U2 N9 }: K1 W链接脚本的一个主要目的是描述输入文件中的各个段(数据段,代码段,堆,栈,bss)如何被映射到输出文件中,并控制输出文件的内存排布.

8 f0 L9 _  P# [3 B& P链接器总是使用链接脚本的,如果你不提供,则链接器会使用一个缺省的脚本,这个脚本是被编译进链接器可执行文件的.

可以使用--verbose命令行显示缺省的链接器脚本的内容.

% W: N& `0 s- T( q你可以使用-T命令行来提供你自己的链接脚本来替换缺省的链接脚本.

+ \' P- e7 O9 h% Y, w& E2 Z三、简单的链接脚本示例.

" b' Q) \3 L; v* l' `许多脚本是相当简单的.
3 O0 G9 A$ H! n8 R* l9 Q! b
可能最简单的脚本只含有一个命令:’SECTIONS’.

# o8 o  D. m% L. E你可以使用’SECTIONS’来描述输出文件的内存布局.
3 a: F6 w3 Y! [. _# |# }! z
‘SECTIONS’是一个功能很强大的命令.

5 b4 L8 E$ A" n3 B/ L: ]假设你的程序只有代码段,初始化过的数据段,和未初始化过的数据段.这些会存在于’.text’,’data’,’bss’段中.

5 d5 [- V/ {4 y( e" G对于这个例子,假设代码应该被载入到地址0x1000处,而数据应该从0x8000000开始,如下是实现这个功能的脚本:

SECTIONS

0 @' {0 d% {; V{
& g/ Y, k" p" D2 d# B/ y( @3 h
' X6 Q' O1 ]# |3 X.=0x1000;
4 }( }' {: q0 }1 N. @4 {
.text:{*(.text)}

.=0x8000000;
( I: J6 o" S5 T0 Z& b6 C
.data:{*(.data)}

.bss:{*(.bss)}

8 {0 O7 J/ {$ T8 [& F* x0 c}

具体分析:

* Q. J1 t( X; B: ?8 j% @8 f% ?1 P关键字’SECTIONS’开始于这个配置.后面跟有一串放在花括号中的符号赋值和输出端描述的内容.
, W2 H. {- j* C% A' p) K& @  X; J
第一行是对一个特殊的符号’.’赋值,这是一个定位标识器.如果你没有以其他的方式制定输出段的地址,那地址值就会被设为定位标识器的现有值,即0x1000.
1 |/ q: i! E, R3 {4 D5 X2 M9 B# a4 h4 k
( L5 V+ T! K5 D+ o第二行定义一个输出段,’.text’.冒号’:’是语法需要,现在可以被忽略.段后面的花括号中,应该列出所有应该放入这个输出段中的输入端的名字.’*’是通配符,匹配所有文件名.即将所有输入文件中的.text段都保存在此段中.

余下的是.data和.bss段,同理,链接器会把所有.data段从地址0x8000000开始处放置.
1 n, e3 {0 @% Z" j4 `1 s
最后,定位标识器的值变为0x8000000加上所有.data段的地址.此时链接器把所有.bss放在此处开始的地址.
3 c" X5 |* j) k9 n- y' b, u2 L


; H; z- y+ M2 ?- i$ {2 A四、简单的链接脚本命令
1 l" b, d) ~+ G6 b4 P9 V$ e
设置入口点
3 \- q* ?% Q7 z4 _6 M( D
在运行一个程序时,第一个被执行到的指令成为”入口点”.你可以使用”ENTRY”链接脚本命令来设置入口点.参数是一个符号名,如下:

ENTRY(SYMBOL)
. ^* E) p/ V7 }/ z
有很多不同的方法来设置入口点.链接器会通过按顺序尝试一下方法来设置入口点,如果成功了,就会停止.
6 i' L. O8 }4 M& U. Y, `
1,’-e’ 入口命令行选项

2,链接脚本中的ENTRY(SYMBOL)命令

3,如果定义了start,就使用start的值

4,如果存在就使用’.text’段的首地址

5,地址’0’
5 i; R$ k5 G$ K, d" L2 T
( b) O: N, H4 }2 k  }: l3 D. Z' r


+ B* G7 j5 ?9 z+ B6 u( B, C
) q  T; p: Y$ G- _$ U8 h4 |
3 o- f# R+ t% P. V& T/ M; H7 Q! D
五、命令行设置链接地址
/ s. D6 E8 r5 K' a* d
+ f& F- P; M; W  zld用于将多个obj或者so(库)文件链接成可执行文件.
. g/ _! I/ Y3 E- }8 {
使用-T选项可以指定数据段,代码段,bss段起始位置.(-T只用于链接bootloader、内核等没有底层软件支持的软件.链接运行于操作系统之上的应用程序时,一般使用默认方式链接).
) A- W8 p! o/ V, N1 R7 A
1,直接指定代码段、数据段、bss段起始地址
, ]% t1 U9 z( |* S4 N
( Y  ]! G9 X  z- f, _) ~$ H5 W如下:

-Ttext startaddr

-Tdata startaddr

-Tbss  startaddr
" P' `; e6 ?9 ^( w4 v) o
例如:

/ l4 o9 E( h7 @$ D! eld –Ttext 0x00000000 –g led_on.o –o led_on_elf

+ V% u; a; W2 u2,直接使用链接脚本来设置起始地址

ld –Ttimer.lds –o timer_elf a.o b.o

+ E' @- \5 ?2 i4 B链接脚本timer.lds内容如下:

! z1 m" x. V' }& QSECTIONS{
3 U( E( @8 n) z3 E
8 R7 \/ u5 K! V% s: G  P; `1 A.=0x30000000;
* s8 S! H8 ?, e" [  h! H6 q8 e
.text : {*(.text)}
* E, E9 M& A; D7 y7 }" Z
0 r$ y9 o4 q! ?# I! C; z.rodata ALIGN(4) : {*(.rodata)}

.data ALIGN(4) : {*(.data)}

2 r6 l" j5 [$ M9 A; ~1 D% m2 N.bss ALIGN(4) : {*.(.bss) *(COMMON)}

}

! B( Q1 n' w* \( n一个SECTIONS命令内部包含一个或多个段,段(section)是连接脚本的基本单元,它表示输入文件中的某部分怎么放置.

kenson

ld链接脚本文件语法解析之一
! Y) k, o  {( M+ f
6 E1 l( |. o+ |0 x  F5 F连接脚本

**************



: J7 u4 Q0 p4 z7 z* A连接脚本的一个主要目的是描述输入文件中的节如何被映射到输出文件中,并控制输出文件的内存排布. 几乎所有的连接脚本只做这两件事情. 但是,在需要的时候,连接器脚本还可以指示连接器执行很多其他的操作.这通过下面描述的命令实现.

5 c1 {9 ~$ c  P" G# W# n- p/ u7 W连接器总是使用连接器脚本的.如果你自己不提供, 连接器会使用一个缺省的脚本,这个脚本是被编译进连接器可执行文件的. 你可以使用'--verbose'命令行选项来显示缺省的连接器脚本的内容. 某些命令行选项,比如

'-r'或'-N', 会影响缺省的连接脚本.
" `2 i+ _9 `6 `3 `# h& x1 D; l
你可以过使用'-T'命令行选项来提供你自己的连接脚本. 当你这么做的时候, 你的连接脚本会替换缺省的连接脚本.
* `3 _/ Y( X# N8 {8 `
; y& E' V! x9 E- [- U  W. E. S你也可以通过把连接脚本作为一个连接器的输入文件来隐式地使用它,就象它们是一个被连接的文件一样.
! R. V. o+ X* V# \: k
3 u4 N; @' b5 T% g% T) [
- {( B7 M% G: @3 U; ~7 n
- X% b2 ]% W/ R. L基本的连接脚本的概念

============================
* V2 s; D# X& ^: [( x6 ?- L' O
% M5 y; }# X9 `8 x我们需要定义一些基本的概念与词汇以描述连接脚本语言.

连接器把多个输入文件合并成单个输出文件. 输出文件和输入文件都以一种叫做'目标文件格式'的数据格式形式存在. 每一个文件被叫做'目标文件'. 输出文件经常被叫做'可执行文件',但是由于需要,我们也把它叫做目标文件. 每一个目标文件中,在其它东西之间,有一个节列表.我们有时把输入文件的节叫做输入节; 相似的,输出文件中的一个节经常被叫做输出节.
7 F8 M7 d" M6 X
- N- e* m, t* R# c' t一个目标文件中的每一个节都有一个名字和一个大小尺寸. 大多数节还有一个相关的数据块, 称为节内容. 某一个节可能被标式讵'loadable',含义是在输出文件被执行时,这个节应当被载入到内存中去. 一个没有内容的节可能是'allocatable', 含义是内存中必须为这个节开辟一块空间,但是没有实际的内容载入到这里(在某些情况下,这块内存必须被标式讵零). 一个既不是loadable也不是allocatable的节一般含有一些调试信息.
% v* M, i2 Z$ A' R
每一个loadable或allocatable的输出节有两个地址. 第一个是'VMA'或称为虚拟内存地址. 这是当输出文件运行时节所拥有的地址. 第二个是"LMA', 或称为载入内存地址. 这个节即将要载入的内存地址. 这大多数情况下这两个地址是相同的. 它们两个有可能不同的一个例子是当一个数据节在ROM中时, 当程序启动时,被拷贝到RAM中(这个技术经常被用在基于ROM的系统中进行全局变量的初始化). 在这种情况下, ROM地址就是LMA, 而RAM地址就是VMA.

你可以通过使用带有'-h'选项的'objdump'来察看目标文件中的节.
6 o- u1 O" Q( B4 ?2 Y' r+ u
  E' G% C; a5 B5 V2 z& y每一个目标文件还有一个关于符号的列表, 被称为'符号表'. 一个符号可能是定义过了的,也可能是未定义的.
- \) o5 \: H6 u! Y  P& U7 q
' l6 t$ ?/ M7 ]; p每一个符号有一个名字, 而且每一个定义的符号有一个地址. 如果你把一个C/C++程序编译为一个目标文件,对于每一个定义的函数和全局或静态变量,你为得到一个定义的符号. 每一个在输入文件中只是一个引用而未定义的函数或全局变量会变成一个未定义的符号.

你可以使用'nm'程序来看一个目标文件中的符号, 或者使用'objdump'程序带有'-t'选项.
7 M5 O# x0 Q5 d5 ^3 B9 K
: O7 w- A4 _( U: |. V+ E

连接脚本的格式

====================

连接脚本是文本文件.

9 Z0 P" o/ A, i7 X" z4 C你写了一系列的命令作为一个连接脚本. 每一个命令是一个带有参数的关键字,或者是一个对符号的赋值. 你可以用分号分隔命令. 空格一般被忽略.
" t! |* t, Q7 i) _" k. [
; ]: o( s  _) b; R文件名或格式名之类的字符串一般可以被直接键入. 如果文件名含有特殊字符,比如一般作为分隔文件名用的逗号, 你可以把文件名放到双引号中. 文件名中间无法使用双引号.
& F! S- t/ S, @
. M6 V) H6 x5 @/ l2 K' ~) l8 L你可以象在C语言中一样,在连接脚本中使用注释, 用'/*'和'*/'隔开. 就像在C中,注释在语法上等同于空格.

+ A$ v/ D  i. U8 h2 p

( W# A1 x8 O! _, S
5 K, Q7 S2 w5 G+ V1 F$ V) ~8 R/ G7 F
" {9 C# _/ X1 u, A5 ]& E简单的连接脚本示例

============================

许多脚本是相当的简单的.
9 k5 x  W4 Q9 l2 j
可能的最简单的脚本只含有一个命令: 'SECTIONS'. 你可以使用'SECTIONS'来描述输出文件的内存布局.
1 @" T2 I4 \1 K. i4 b* y1 c
  N; g& U8 V' m. J5 K'SECTIONS'是一个功能很强大的命令. 这里这们会描述一个很简单的使用. 让我们假设你的程序只有代码节, 初始化过的数据节, 和未初始化过的数据节. 这些会存在于'.text','.data'和'.bss'节, 另外, 让我们进一步假设在你的输入文件中只有这些节.

( w0 J5 P" Z- C% D! g9 }对于这个例子, 我们说代码应当被载入到地址'0x10000'处, 而数据应当从0x8000000处开始. 下面是一个实现这个功能的脚本:
, f4 f# \3 c* ?- n; A3 j, |
SECTIONS

8 x  ]. \8 u# O0 \' @{

  a" u( R: e8 k. = 0x10000;
# Z- p7 |  X4 Z! d
1 [( l/ s: l/ N/ a4 u( L5 I  w( H.text : { *(.text) }

, R2 i4 m# `( U9 i+ Q3 Y. = 0x8000000;
2 t8 {$ ^7 O# k- \6 s
0 A9 e/ D8 ?# s8 Z: M6 f; f.data : { *(.data) }

.bss : { *(.bss) }
5 A/ v# K, [. w: v
/ n% j8 u5 p( a$ G- U}

! \* T5 d) `. d: K  ^& q5 a你使用关键字'SECTIONS'写了这个SECTIONS命令, 后面跟有一串放在花括号中的符号赋值和输出节描述的内容.

9 }8 _2 r+ L- ?) o6 w. Q, P$ `上例中, 在'SECTIONS'命令中的第一行是对一个特殊的符号'.'赋值, 这是一个定位计数器. 如果你没有以其它的方式指定输出节的地址(其他方式在后面会描述), 那地址值就会被设为定位计数器的现有值. 定位计数器然后被加上输出节的尺寸. 在'SECTIONS'命令的开始处, 定位计数器拥有值'0'.
, i5 f+ M% y9 A$ V0 a. x  Z; \, K/ }
$ p* Z( @/ ^. j! \# y  u7 M! v第二行定义一个输出节,'.text'. 冒号是语法需要,现在可以被忽略. 节名后面的花括号中,你列出所有应当被放入到这个输出节中的输入节的名字. '*'是一个通配符,匹配任何文件名. 表达式'*(.text)'意思是所有的输入文件中的'.text'输入节.
* d$ R% }  J6 e, z& M
因为当输出节'.text'定义的时候, 定位计数器的值是'0x10000',连接器会把输出文件中的'.text'节的地址设为'0x10000'.
+ {* b/ P7 f# a5 M# F/ j
' B# k; N( \# F- i余下的内容定义了输出文件中的'.data'节和'.bss'节. 连接器会把'.data'输出节放到地址'0x8000000'处. 连接器放好'.data'输出节之后, 定位计数器的值是'0x8000000'加上'.data'输出节的长度. 得到的结果是连接器会把'.bss'输出节放到紧接'.data'节后面的位置.

( p: J2 {7 i" O$ R' a% O" M+ C连接器会通过在必要时增加定位计数器的值来保证每一个输出节具有它所需的对齐. 在这个例子中, 为'.text'和'.data'节指定的地址会满足对齐约束, 但是连接器可能会需要在'.data'和'.bss'节之间创建一个小的缺口.

1 M' ^) b$ T# X" B' X4 `就这样,这是一个简单但完整的连接脚本.
. p8 L3 e7 W( A+ Y1 [. e7 J

- Z( u3 G& f5 v$ J
, e$ o0 \' C8 M& n7 f每个连接都被一个'连接脚本'所控制. 这个脚本是用连接命令语言书写的.

kenson

http://wenku.baidu.com/view/a3c428f4f61fb7360b4c6501.html

kenson

ld链接脚本语法简介
; i: @& d  V4 u# E1 m. p6 R
主要包含命令语句和赋值语句。
( M; @+ q0 O) W' l/ G- C8 {


一、语法
" p+ o* t" D7 i
1、分号，作为分隔符号  
3 e; p: [1 s/ M* ^$ w
2、注释 表达式和运算符  和c一样，其中注释只有/**/
! w' A& \7 J# L# Q9 l
3、字符引用  段名文件名等有特殊字符，使用双引号
  V& @5 M9 v1 \0 _, C- K8 Y
: ~3 }8 A1 V) V. Y4、命令语句
' d, R$ X0 \, ?' ?! X
a、ENTRY（symble）  指定入口地址，入口地址就是进程执行的第一条用户空间的指令再进程地址空间中的地址，被指定再ELF文件头的ELF32_Ehdr的e_entry成员中。
; A" p& w! x& |. W" @" C& u( g) M
1 F# P6 G- M  o) G' z+ eld有多种指定程序入口方式：(优先级逐渐降低)
6 W& l7 f3 g- S9 V/ b! c* T
- P: h; w4 V6 L; q2 }ld -e
. ]  J2 ]6 B2 Q
entry（）
" {/ Q4 \# y' w( c1 e# d; I
& K, l( ?' a+ J( K, c_start符号
$ {* R7 z1 B7 {. T
.text
6 Q* T' k  Y/ x# G9 B
" }4 n" y) v  k3 m' A* n( U0



/ r3 @5 b, j) x' D, `9 W0 Eb、STARTUP(filename)  将文件filename 作为链接过程中的第一个输入文件。

c、SEATCH_DIR 将路径path加入到ld链接器的库查找目录。 ld会根据指定的目录去查找相应的库。

d、INPUT(file,file,...)  将指定文件作为链接过程中的输入文件
# @# C; B% o0 {0 u9 g% p6 h$ S4 T
e、INCLUDE filename 将指定文件包含进本链接脚本。

f、PROVIDE（symbol） 在链接脚本中定义某个符号。该符号再程序中可以被引用，起始前文提到的特殊符号都是由系统默认的链接脚本通过PROVIDE 命令定义在脚本中的
* t  R1 X& Y2 f7 @; R  l


最复杂的SECTIONS
! T' P' O. M, [7 m& i5 T
2 i5 G. b2 O; m- d  {& XSECTIONS
% p( W$ q3 _2 E' L4 J
; `5 Y2 A9 H' G- ?. z0 B* K. J  U{

  secname : {contents}
3 @4 r2 q5 J+ P+ \  u/ R) c& L
0 g% H% t5 U8 h" w% D( l" D' E}

secname 表示 输出段的段名，后面必须有一个空格，使得输出段名没有歧义，后面根一个冒号和一对大括号。大括号里面的contents描述了一套规则和条件，表示符合这种条件的输入段合并到输出段中。输出段名必须符号输出文件的要求，例如：a.out 输出段名不可以是.text

.data .bss 之外的名字，因为.a.out 规定只允许这三个名。

) I' b0 F, f. c" `- q有一个特殊的段名/DISCARD/如果使用这个名字作为输出，那么所有符合条件的段都丢弃
% S- S( g$ l+ W3 Q/ k/ E


contents 规则
. g" t: |0 H1 I) X' W; ?. f( q8 Z
包含若干个条件，每个条件用空格分开，如果输入段符合任一条件，就表示符合cotents规则
- f( u  D$ U5 P+ K2 u, ~, G
输入规则 ：filename(sections)
& T7 A+ M$ P6 U; j1 k) q
2 i! d2 u* ?" P& Y) K, U! i

  |: f7 m9 w- |) c' N8 Y6 q2 b
  X( k1 g2 R3 y
# K# q8 Z9 a" YENTRY(nomain)  //指定了程序的入口地址

3 T" `) O1 z# N) K, b- ^6 ASECTIONS  //链接脚本的主体

6 F3 L: M( M2 G' T{
1 }9 Z1 i- T( u4 ^! s2 k
  . = 0x08048000 + SIZEOF_HEADERS;  //将当前虚拟地址设置为0x08048000 + sizeof_headers.

9 [  Z' Y& A5 u0 D: d其中 “.”表示当前虚拟地址

* x9 S/ f6 |" C7 F* p6 S8 B6 r SIZEOF_HEADERS 表示文件的文件头大小
% o7 K2 Q/ \9 b+ P1 s5 ]


* q9 n- I+ s9 c0 r3 [, V# L9 E8 I  tinytext : {*(.text) *(.data) *(.rodata)} //将所有输入文件中的三个段合并为输出文件中的 tinytext段。
3 h( c& i/ P  s: ~/ p: E


1 W' {2 n8 `7 z# v5 q: _. z0 J0 g  /DISCARD/ : {*(.comment)}  //将输入文件的comment段丢弃

}

zhixiaoyuhong

哇，很不错，讲的很好，顶一个。。。