【韦东山旧1期学习笔记】08.S3C2440 代码重定位实验（二）

港控/mmm° 2023-07-04 15:41 5阅读 0赞

### 目录 ###

*  重定位和链接脚本
 *   *  思路一：只重定位数据段
     *  思路二：重定位整个程序
 *  链接脚本
 *   *  基本概念
     *   *  虚拟内存地址VMA 和 加载内存地址LMA
     *  链接脚本的格式
     *  最简单的例子
     *  常用的链接脚本命令
     *   *  设置程序的入口点
         *  处理文件相关的命令
         *  处理目标文件格式的命令
     *  符号赋值语句
     *   *  变量和赋值运算符之间的空白符
         *  简单赋值语句
         *  C语言实例
         *  PROVIDE
     *  SECTIONS命令
     *   *  输出段描述
         *  输出段名称
         *  输出段地址
         *  输入段描述
         *   *  输入段之基础
         *  输出段的加载内存地址LMA
     *  常用内置函数
     *   *  ABSOLUTE(exp)
         *  ADDR(SECTION)
         *  ALIGN(EXP)
         *  BLOCK(EXP)
         *  DEFINED(SYMBOL)
         *  LOADADDR(SECTION)
         *  MAX(EXP1,EXP2)
         *  MIN(EXP1,EXP2)
         *  NEXT(EXP)
         *  SIZEOF(SECTION)

# 重定位和链接脚本 #

经过上一篇文章的讲述，我们了解了无论是从Nor启动还是从Nand启动，都存在代码的重定位问题。我们接下来就要解决程序加载时的代码重定位问题。我们再回顾一下上一篇文章中所使用的Makefile文件，如下所示：

CROSS_COMPILE_PREFIX=arm-linux-
    CFLAGS=-g
    TARGET=relocate
    
    $(TARGET).bin : CRT0.o uart.o myprintf.o Ctype.o sdram.o util.o $(TARGET).o main.o
    	$(CROSS_COMPILE_PREFIX)ld -Ttext 0x0000000 -Tdata 0xE40 -o $(TARGET).elf $^
    	$(CROSS_COMPILE_PREFIX)objcopy -O binary -S $(TARGET).elf $@
    	$(CROSS_COMPILE_PREFIX)objdump -D $(TARGET).elf > $(TARGET).dis
    
    CRT0.o : CRT0.S
    	$(CROSS_COMPILE_PREFIX)gcc $(CFLAGS) -c -o $@ $^
    myprintf.o : myprintf.c stdarg.h
    	$(CROSS_COMPILE_PREFIX)gcc $(CFLAGS) -o $@ -c $< 
    uart.o : uart.c stdarg.h s3c2440_soc.h
    	$(CROSS_COMPILE_PREFIX)gcc $(CFLAGS) -o $@ -c $< 
    $(TARGET).o : $(TARGET).c 
    	$(CROSS_COMPILE_PREFIX)gcc $(CFLAGS) -o $@ -c $<
    main.o : main.c
    	$(CROSS_COMPILE_PREFIX)gcc $(CFLAGS) -o $@ -c $<
    Ctype.o : Ctype.c Ctype.h
    	$(CROSS_COMPILE_PREFIX)gcc $(CFLAGS) -o $@ -c $<
    util.o : util.c util.h
    	$(CROSS_COMPILE_PREFIX)gcc $(CFLAGS) -o $@ -c $<
    sdram.o : sdram.c sdram.h
    	$(CROSS_COMPILE_PREFIX)gcc $(CFLAGS) -o $@ -c $<
    
    clean:
    	rm -f *.elf *.dis *.bin *.o

从Makefile中可以看出，我们在链接时，指定了代码段的地址为0x0开始，数据段的地址从0xE40开始。  
        当我们使用Nor Flash启动时，0xE40对应的Nor Flash的地址空间，所以直接修改数据段的全局变量会失败。对此，我们的第一反应就是需要将数据段指定到SDRAM中，这样程序就应该可以正常运行了。为此，我们将数据段的地址指定为0x30000000，即SDRAM的起始地址，重新编译，结果如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70]  
        我们发现，编译出来的BIN文件竟然有769MB，其大小已经远远超出了存储器可以容纳的大小，这样显然是无法烧写到Nor Flash或者是Nand Flash中的。为什么会这样呢？我们可以将BIN文件的大小805306369转换成十六进制，即0x‭30000001‬，而查看反汇编文件可知数据段确实是在0x30000000地址处，占据1个字节的大小：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 1]  
        所以BIN文件的结尾地址是0x30000001就得到了解释。这表明如果我们像上面那样指定数据段的偏移地址，那么我们编译得到的文件就会这么大。在BIN文件的代码段和数据段之间显然存在着一个巨大的黑洞。显然，这样做是错误的，需要进一步改进。怎么解决呢？有两个思路。

## 思路一：只重定位数据段 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 2]  
        我们仍然按照上面的方法，指定代码段在0x0处，而数据段仍在0x30000000处，但是让BIN文件中代码段和数据段挨在一起，去掉之前存在的黑洞。这样就可以让BIN文件恢复到4KB大小之内。在程序加载时，需要我们把BIN文件中数据段部分拷贝到指定的链接地址上去。

## 思路二：重定位整个程序 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 3]  
我们指定代码段时就设置为0x30000000处，其余部分依次偏移，这样BIN文件的大小就和原来完全一样。这样，在加载时，我们需要把整个程序都进行重定位，全部拷贝至SDRAM中。

无论时方法一，还是方法二，在链接时都涉及到更细致的操作，单靠链接命令行参数已经无法满足要求，需要引入一个非常有用的工具——链接脚本。

# 链接脚本 #

通常情况下，所有链接过程都有一个链接脚本来予以控制。而用来书写链接脚本的语言就是链接命令语言。链接脚本的主要目的就是用来描述给定的输入目标文件中的所有的段是怎样映射到单一的输出目标文件中的，与此同时，链接脚本还控制着输出目标文件在内存中的布局。绝大多数情况下，这两点就是链接脚本所负责的全部工作了。但是，链接脚本还可以使用下文所描述的命令来指导链接器进行其他一些操作。  
        链接器总会使用一个链接脚本。如果我们不指定一个的话，链接器会使用默认的链接脚本。关于这个内置的默认链接脚本，我们可以使用–verbose命令行选项来查看。同时一些命令行选项参数会影响默认的链接脚本的行为。

macrofun@BIgBrotherU:~$ arm-linux-ld --verbose

GNU ld (Sourcery G++ Lite 2008q3-72) 2.18.50.20080215
      Supported emulations:
       armelf_linux_eabi
       armelfb_linux_eabi
    using internal linker script:
    ==================================================
    /* Script for -z combreloc: combine and sort reloc sections */
    OUTPUT_FORMAT("elf32-littlearm", "elf32-bigarm",
    	      "elf32-littlearm")
    OUTPUT_ARCH(arm)
    ENTRY(_start)
    SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib");
    SECTIONS
    { 
      /* Read-only sections, merged into text segment: */
      PROVIDE (__executable_start = 0x00008000); . = 0x00008000 + SIZEOF_HEADERS;
      .interp         : {  *(.interp) }
      .note.gnu.build-id : {  *(.note.gnu.build-id) }
      .hash           : {  *(.hash) }
      .gnu.hash       : {  *(.gnu.hash) }
      .dynsym         : {  *(.dynsym) }
      .dynstr         : {  *(.dynstr) }
      .gnu.version    : {  *(.gnu.version) }
      .gnu.version_d  : {  *(.gnu.version_d) }
      .gnu.version_r  : {  *(.gnu.version_r) }
      .rel.dyn        :
        { 
          *(.rel.init)
          *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*)
          *(.rel.fini)
          *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*)
          *(.rel.data.rel.ro* .rel.gnu.linkonce.d.rel.ro.*)
          *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*)
          *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*)
          *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*)
          *(.rel.ctors)
          *(.rel.dtors)
          *(.rel.got)
          *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*)
        }
      .rela.dyn       :
        { 
          *(.rela.init)
          *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
          *(.rela.fini)
          *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
          *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
          *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
          *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
          *(.rela.ctors)
          *(.rela.dtors)
          *(.rela.got)
          *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
        }
      .rel.plt        : {  *(.rel.plt) }
      .rela.plt       : {  *(.rela.plt) }
      .init           :
      { 
        KEEP (*(.init))
      } =0
      .plt            : {  *(.plt) }
      .text           :
      { 
        *(.text .stub .text.* .gnu.linkonce.t.*)
        /* .gnu.warning sections are handled specially by elf32.em.  */
        *(.gnu.warning)
        *(.glue_7t) *(.glue_7) *(.vfp11_veneer) *(.v4_bx)
      } =0
      .fini           :
      { 
        KEEP (*(.fini))
      } =0
      PROVIDE (__etext = .);
      PROVIDE (_etext = .);
      PROVIDE (etext = .);
      .rodata         : {  *(.rodata .rodata.* .gnu.linkonce.r.*) }
      .rodata1        : {  *(.rodata1) }
      .ARM.extab   : {  *(.ARM.extab* .gnu.linkonce.armextab.*) }
       __exidx_start = .;
      .ARM.exidx   : {  *(.ARM.exidx* .gnu.linkonce.armexidx.*) }
       __exidx_end = .;
      .eh_frame_hdr : {  *(.eh_frame_hdr) }
      .eh_frame       : ONLY_IF_RO {  KEEP (*(.eh_frame)) }
      .gcc_except_table   : ONLY_IF_RO {  *(.gcc_except_table .gcc_except_table.*) }
      /* Adjust the address for the data segment.  We want to adjust up to
         the same address within the page on the next page up.  */
      . = ALIGN (CONSTANT (MAXPAGESIZE)) - ((CONSTANT (MAXPAGESIZE) - .) & (CONSTANT (MAXPAGESIZE) - 1)); . = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
      /* Exception handling  */
      .eh_frame       : ONLY_IF_RW {  KEEP (*(.eh_frame)) }
      .gcc_except_table   : ONLY_IF_RW {  *(.gcc_except_table .gcc_except_table.*) }
      /* Thread Local Storage sections  */
      .tdata	  : {  *(.tdata .tdata.* .gnu.linkonce.td.*) }
      .tbss		  : {  *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
      .preinit_array     :
      { 
        PROVIDE_HIDDEN (__preinit_array_start = .);
        KEEP (*(.preinit_array))
        PROVIDE_HIDDEN (__preinit_array_end = .);
      }
      .init_array     :
      { 
         PROVIDE_HIDDEN (__init_array_start = .);
         KEEP (*(SORT(.init_array.*)))
         KEEP (*(.init_array))
         PROVIDE_HIDDEN (__init_array_end = .);
      }
      .fini_array     :
      { 
        PROVIDE_HIDDEN (__fini_array_start = .);
        KEEP (*(.fini_array))
        KEEP (*(SORT(.fini_array.*)))
        PROVIDE_HIDDEN (__fini_array_end = .);
      }
      .ctors          :
      { 
        /* gcc uses crtbegin.o to find the start of
           the constructors, so we make sure it is
           first.  Because this is a wildcard, it
           doesn't matter if the user does not actually link against crtbegin.o; the linker won't look for a file to match a
           wildcard.  The wildcard also means that it
           doesn't matter which directory crtbegin.o is in. */ KEEP (*crtbegin.o(.ctors)) KEEP (*crtbegin?.o(.ctors)) /* We don't want to include the .ctor section from
           the crtend.o file until after the sorted ctors.
           The .ctor section from the crtend file contains the
           end of ctors marker and it must be last */
        KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
        KEEP (*(SORT(.ctors.*)))
        KEEP (*(.ctors))
      }
      .dtors          :
      { 
        KEEP (*crtbegin.o(.dtors))
        KEEP (*crtbegin?.o(.dtors))
        KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
        KEEP (*(SORT(.dtors.*)))
        KEEP (*(.dtors))
      }
      .jcr            : {  KEEP (*(.jcr)) }
      .data.rel.ro : {  *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*) }
      .dynamic        : {  *(.dynamic) }
      . = DATA_SEGMENT_RELRO_END (0, .);
      .got            : {  *(.got.plt) *(.got) }
      .data           :
      { 
        __data_start = . ;
        *(.data .data.* .gnu.linkonce.d.*)
        SORT(CONSTRUCTORS)
      }
      .data1          : {  *(.data1) }
      _edata = .; PROVIDE (edata = .);
      __bss_start = .;
      __bss_start__ = .;
      .bss            :
      { 
       *(.dynbss)
       *(.bss .bss.* .gnu.linkonce.b.*)
       *(COMMON)
       /* Align here to ensure that the .bss section occupies space up to
          _end.  Align after .bss to ensure correct alignment even if the
          .bss section disappears because there are no input sections.
          FIXME: Why do we need it? When there is no .bss section, we don't
          pad the .data section.  */
       . = ALIGN(. != 0 ? 32 / 8 : 1);
      }
      _bss_end__ = . ; __bss_end__ = . ;
      . = ALIGN(32 / 8);
      . = ALIGN(32 / 8);
      __end__ = . ;
      _end = .; PROVIDE (end = .);
      . = DATA_SEGMENT_END (.);
      /* Stabs debugging sections.  */
      .stab          0 : {  *(.stab) }
      .stabstr       0 : {  *(.stabstr) }
      .stab.excl     0 : {  *(.stab.excl) }
      .stab.exclstr  0 : {  *(.stab.exclstr) }
      .stab.index    0 : {  *(.stab.index) }
      .stab.indexstr 0 : {  *(.stab.indexstr) }
      .comment       0 : {  *(.comment) }
      /* DWARF debug sections.
         Symbols in the DWARF debugging sections are relative to the beginning
         of the section so we begin them at 0.  */
      /* DWARF 1 */
      .debug          0 : {  *(.debug) }
      .line           0 : {  *(.line) }
      /* GNU DWARF 1 extensions */
      .debug_srcinfo  0 : {  *(.debug_srcinfo) }
      .debug_sfnames  0 : {  *(.debug_sfnames) }
      /* DWARF 1.1 and DWARF 2 */
      .debug_aranges  0 : {  *(.debug_aranges) }
      .debug_pubnames 0 : {  *(.debug_pubnames) }
      /* DWARF 2 */
      .debug_info     0 : {  *(.debug_info .gnu.linkonce.wi.*) }
      .debug_abbrev   0 : {  *(.debug_abbrev) }
      .debug_line     0 : {  *(.debug_line) }
      .debug_frame    0 : {  *(.debug_frame) }
      .debug_str      0 : {  *(.debug_str) }
      .debug_loc      0 : {  *(.debug_loc) }
      .debug_macinfo  0 : {  *(.debug_macinfo) }
      /* SGI/MIPS DWARF 2 extensions */
      .debug_weaknames 0 : {  *(.debug_weaknames) }
      .debug_funcnames 0 : {  *(.debug_funcnames) }
      .debug_typenames 0 : {  *(.debug_typenames) }
      .debug_varnames  0 : {  *(.debug_varnames) }
      /* DWARF 3 */
      .debug_pubtypes 0 : {  *(.debug_pubtypes) }
      .debug_ranges   0 : {  *(.debug_ranges) }
      .gnu.attributes 0 : {  KEEP (*(.gnu.attributes)) }
      .note.gnu.arm.ident 0 : {  KEEP (*(.note.gnu.arm.ident)) }
      /DISCARD/ : {  *(.note.GNU-stack) *(.gnu_debuglink) }
    }
    
    
    ==================================================

我们可以使用-T选项来使用我们自己的链接脚本。我们也可以隐式地使用链接脚本，即把链接脚本作为输入文件传给链接器，就好像它也是待链接的目标文件一样。

## 基本概念 ##

为了学习链接脚本，我们需要引入一些基本概念和词汇来对链接脚本语言进行描述。链接器将给定的多个输入文件转化合并成一个单一的输出文件。无论是这些输入文件，还是最终的输出文件，其格式都是目标文件格式，这些文件都是目标文件。通常情况下，这个最终的输出文件往往是可执行文件，但是基于上一篇文章的介绍，我们知道，它也是属于目标文件。所有的目标文件，或可重定位目标文件，都包含了一系列的段（section）。为了明确起见，对于输入文件中的段，我们称之为输入段；同样，对于输出段，我们称之为输出段。  
        目标文件中的每一个段都有名字和空间大小。大多数的段都含有数据块，这些数据被称作段内容。一个段可以被标记为可加载（loadable），这就意味着在程序运行时这些内容需要被加载到内存中。对于一个不含有任何内容的段，可以把它作为可分配（allocatable）的段。在程序加载时，对于可分配的段，我们需要在内存中分配出相应的空间，但并不需要专门加载什么段内容（因为这些段本来也没有内容）。当然，对于bss段，我们需要把对应的内存空间做清零处理。如果一个段既不是可加载的（loadable），也不是可分配的（allocatable），那么通常情况下这个段会含有某些调试信息。

### 虚拟内存地址VMA 和 加载内存地址LMA ###

输出目标文件中每一个可加载的（loadable）或可分配的（allocatable）的段都有两个地址，一个叫做虚拟内存地址（VMA, Virtual Memory Address），另一个叫做可加载内存地址（LMA, Load Memory Address）。VMA是输出目标文件运行时的地址，而LMA则是该段被加载到的地址。大多数情况下这两个地址是相同的。而正如上面我们Nor Flash遇到的问题，我们的数据段被加载到了Nor Flash中，但是程序运行时，我们需要将数据段拷贝到SDRAM中。在这种情况下，LMA和VMA就需要不一样。对于在类似于Nor Flash这样的ROM中的地址，我们称之为LMA；而在SDRAM中的地址，我们称之为VMA。  
        由上面的分析我们可知，当程序需要修改基于ROM系统中的全局变量时，VMA和LMA就会不一样。我们可以通过使用arm-linux-objdump -h命令来查看elf目标文件中的各段的大小、偏移量、VMA和LMA等信息，如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 4]  
我们可以发现，其数据段的VMA和LMA不一样，VMA对应的是SDRAM内存的起始地址，而LMA对应的是Nor Flash中的加载地址。  
        每个目标文件中总是含有一张符号表，用于存储各种符号信息。一个符号可以是已定义的（defined），也可以是未定义的（undefined）。每个符号都有一个名字，同时每一个已定义的符号有一个地址。如果我们编译的是C或C++程序，那么这个目标文件中的所有定义过的函数、全局变量或者静态变量都对应一个已定义符号，而本文件外部引用的其他函数和全局变量则对应一个未定义符号。我们可以通过arm-linux-nm程序，或者使用arm-linux-objdump -t来查看目标文件中的符号表信息。

## 链接脚本的格式 ##

首先，链接脚本是一个纯文本文件。我们可以在链接脚本中写一系列的命令。每个命令要么是一个可能含有参数的关键字命令，要么是一个符号赋值语句。每个命令以分号结尾。而像空格、TAB制表符等空白符则会被忽略。  
        在链接脚本中，我们可以像C语言那样使用注释/\* \*/。

## 最简单的例子 ##

最简单的链接脚本只包含一个命令：“SECTIONS”。我们使用‘SECTIONS’命令来描述输出目标文件的内存布局。‘SECTIONS’命令是一个非常有用的命令。我们假设程序只包括二进制代码、已经初始化的数据和尚未初始化的数据。那么这三个部分分别对应.text段、.data段和.bss段。为简单起见，我们再假设在所有输入目标文件中，只存在这三种段。  
        针对上面的例子，我们假设代码段需要被加载到地址0x10000处，而数据段需要被加载到地址0x8000000。据此我们可以写出相应的链接脚本文件如下所示：

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

SECTIONS命令以关键字SECTIONS开头，后跟一对花括号。在花括号内部，有一系列的符号赋值语句和输出段描述信息。上面例子中SECTIONS命令内部的第一行中的.就是地址计数器（location counter）。如果你没有指定一个输出段的地址，则该段的地址就是当前地址计数器的值。之后，地址计数器会自增，自增的大小就是该段的大小。在SECTIONS命令的开头第一行处，地址计数器的值为0。  
        第二行定义了一个输出段.text段，后面必须紧跟一个冒号。在后续的花括号内部，我们可以列出我们想放进输出代码段中的输入代码段的名字。这里的\*是通配符，表示可以匹配任意的文件名。\*(.text)表示所有输入文件中的所有的代码段。  
        因为我们首先将地址计数器的值赋为了0x10000，所以链接器会将输出文件中.text段的地址设置为0x10000。  
        接下来的三行定义了输出文件中的.data段和.bss段。同理，输出文件中.data段位于地址0x8000000处。在数据段之后，地址计数器的值就变成了0x8000000加上输出数据段的大小。链接器会在内存中将.bss输出段放在紧挨着.data输出段之后。  
        链接器会保证所有的输出段都是按要求对齐的。如果没有对齐，链接器会在必要的时候增加地址计数器的值，以使得所有段都满足对齐要求。在上面这个例子当中，.text输出段和.data输出段肯定是满足对齐要求的，但是.data输出段之后，链接器可能会偏移一小段空白来使得.bss输出段地址也满足对齐要求。

## 常用的链接脚本命令 ##

### 设置程序的入口点 ###

一个程序的入口点就是指程序第一条要被执行的指令。我们可以使用ENTRY命令来设置入口点。语法格式如下所示：

> ENTRY(symbol)

其中symbol就是入口点标号。  
链接器按照以下顺序从上到下一次尝试设置入口点，一旦成功就设置完毕。

1.  通过链接命令行参数 -e
2.  通过链接脚本中的ENTRY(symbol)命令
3.  如果定义了符号start，则按照start的值
4.  输出.text段的第一个字节的地址
5.  地址0x0

### 处理文件相关的命令 ###

*  INCLUDE filename：  
    包含其他名为filename的链接脚本，相当于C语言中的\#include指令，用以包含另一个链接脚本。链接器会在当前目录或者由-L选项指定的目录中搜索。INCLUDE指令可以嵌套使用, 最大深度为10。即: 文件1内INCLUDE文件2，文件2内INCLUDE文件3，……文件10内INCLUDE文件11，那么文件11内不能再出现 INCLUDE指令了。
 *  INPUT(file, file, …)  
    INPUT(file file …)：  
    将括号内的文件做为链接过程的输入文件。如果在链接脚本中有INPUT (subr.o)，那么每次链接的时候，链接器都会将subr.o链接进来。实际上，只要你愿意，你可以把所有要链接的输入目标文件都写到链接脚本中，那样，在调用链接命令时，在命令行中，你只需输入-T参数来指定链接脚本即可。输入文件也是有限在当前目录进行查找，如果找不到，那么链接器会去搜索库文件路径。如果你使用了INPUT (-lfile)，则链接器会去链接libfile.a文件，就像你是在链接命令行中输入的 -lfile一样。
 *  GROUP(file, file, …)  
    GROUP(file file …) ：  
    指定需要重复搜索符号定义的多个输入文件，这些库文件作为一组被链接器ld重复扫描，直到不再有新的未定义符号出现。GROUP命令类似于INPUT命令，但是它的file必须都是库文件。
 *  OUTPUT(filename) ：  
    定义输出文件的名字。在链接脚本中使用OUTPUT(filename)和在命令行中使用-o filename是完全一样的效果。但是如果它们两者同时使用的话，命令行中的参数优先。你可以使用OUTPUT(filename)来定义一个你喜欢的默认输出文件名，用来替代通常默认的a.out名字。
 *  SEARCH\_DIR(path)：  
    同ld的-L选项一样，不过由-L指定的路径要比它定义的优先被搜索。
 *  STARTUP(filename)：  
    在链接过程中，每个输入文件链接的先后顺序都是按照传入的先后顺序进行的。此命令设置文件filename为第一个输入文件。从而使其位于输出文件的最开头。

### 处理目标文件格式的命令 ###

*  OUTPUT\_FORMAT(bfdname)  
    OUTPUT\_FORMAT(default, big, little) ：  
    OUTPUT\_FORMAT命令设置输出文件使用的BFD格式。它同ld选项-oformat bfdname一样，只不过ld命令行选项的优先级更高。

## 符号赋值语句 ##

我们可以在链接脚本中对符号进行赋值操作。此时该符号被定义为全局的，且每个符号都对应了一个地址。**注意和C语言中赋值的不同**。此处的赋值是更改这个符号对应的地址的值。

### 变量和赋值运算符之间的空白符 ###

有一点需要重点说明一下，赋值语句中 要定义的变量 和 赋值运算符 需要有空白符隔开，不能连在一起写，如下所示：  
example.lds文件

/*语法错误*/
    num=0x41;

在终端执行arm-linux-ld -T example.lds来测试链接脚本语法，结果报语法错误，如下图所示：  
![在这里插入图片描述][20200213143003831.jpg]  
修改example.lds链接脚本，在等号两侧添加空格后，链接脚本语法检查通过：

/*正确*/
    num =0x41;

![在这里插入图片描述][20200213143254840.jpg]

### 简单赋值语句 ###

我们可以使用C语言的赋值运算符对符号进行赋值操作，如下所示：

*  symbol = expression ;
 *  symbol += expression ;
 *  symbol -= expression ;
 *  symbol \*= expression ;
 *  symbol /= expression ;
 *  symbol <<= expression ;
 *  symbol >>= expression ;
 *  symbol &= expression ;
 *  symbol |= expression ;  
    第一条语句定义了符号symbol，其取值为expression。而其他语句使用的前提是，必须已经定义好了symbol语句。最特殊的符号名字是.，它表示地址计数器，只能够用在SECTIONS命令中。  
    **赋值语句必须以分号;结尾**。  
    注意：赋值语句包含4个语法元素（符号名、操作符、表达式、分号）一个也不能少。  
    示例：

floating_point = 0;
    SECTIONS
    { 
    	.text :
    	{ 
    		*(.text)
    		_etext = .;
    	}
    	_bdata = (. + 7) & ~ 7;
    	.data : {  *(.data) }
    }

在这个例子中，符号floating\_point被定义为0。符号\_etext被定义为紧接着.text输出段的下一个字节。符号\_bdata被定义为.text输出段后8字节对齐的位置。

### C语言实例 ###

对于这个链接脚本，我们做如下的实例来进行测试：  
main.c

//main.c
    int gC = 'A';
    
    int main(void){ 
            return gC;
    }

Makefile文件：

CROSS_COMPILE_PREFIX=arm-linux-
    test.bin :  main.o
            $(CROSS_COMPILE_PREFIX)ld -T test.lds $^
            $(CROSS_COMPILE_PREFIX)objcopy -O binary -S test.elf $@
            $(CROSS_COMPILE_PREFIX)objdump -D test.elf > test.dis
            $(CROSS_COMPILE_PREFIX)nm test.elf > test.sym
    
    main.o : main.c
            $(CROSS_COMPILE_PREFIX)gcc -o main.o -c main.c
    
    clean:
            rm -f *.elf *.o *.bin *.dis *.sym

链接脚本如下所示：

floating_point = 0;
    SECTIONS
    { 
            .text :
            { 
                    *(.text)
                    _etext = .;
            }
            _bdata = (. + 7) & ~ 7;
            .data : {  *(.data) }
    }
    
    OUTPUT(test.elf)

make之后我们查看test.dis和test.sym文件如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 5]  
我们看到，.text输出代码段的地址范围是0x0~0x20，而\_etext的值为0x24，即.text段后紧接着的下一个字节。而\_bdata则为其后8字节对齐的地址，即0x28。而数据段的地址仍然为0x24。

仍旧基于上述例子，我们来验证一下链接脚本中的赋值语句和C语言中赋值的不同之处。  
我们在链接脚本中给gC这个char类型的全局变量赋值，如下所示：  
test.lds

floating_point = 0;
    gC = 0x88;
    SECTIONS
    { 
            .text :
            { 
                    *(.text)
                    _etext = .;
            }
            _bdata = (. + 7) & ~ 7;
            .data : {  *(.data) }
    }
    
    OUTPUT(test.elf)

其他文件均保持不变，编译后查看test.dis和test.sym文件如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 6]  
我们可以看到，gC的地址变成了0x88，而gC原来地址0x24处的值没有改变，依旧是’A’(0x41)。所以说，在链接脚本中，我们修改的是C语言变量的地址的值，而不是C语言变量的值。这点区别需要注意。

### PROVIDE ###

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

SECTIONS
    { 
    	.text :
    	{ 
    		*(.text)
    		_etext = .;
    		PROVIDE(etext = .);
    	}
    }

当目标文件内引用了etext符号，却没有定义它时，etext符号对应的地址被定义为.tex输出t段之后的第一个字节的地址。如果在程序中定义了该变量，则使用程序中定义的值。

## SECTIONS命令 ##

SECTIONS命令用于知道链接器怎样把输入目标文件中的段映射到输出段上，同时指导输出段在存储器中的布局。  
SECTIONS命令的格式如下所示：

SECTIONS
    { 
    	sections-command
    	sections-command
    	...
    }

其中每一个sections-command可以是以下形式之一：

*  一个ENTRY命令
 *  一个符号赋值语句
 *  一个输出段描述
 *  一个重叠（overlay）描述  
    在SECTIONS命令内部，对于ENTRY命令和符号赋值运算，可以使用地址计数器。这样可以使得链接脚本清晰易懂。

如果我们没有在链接脚本中使用SECTIONS命令，那么，链接器会按照命令行中输入目标文件的先后顺序，依次将各个输入段放置在同名输出段中。如果第一个输入目标文件包含所有的输入段名，那么链接器就会按照输入目标文件中段的先后顺序来排列输出目标文件中所有段的次序。第一个段的地址是0。

### 输出段描述 ###

完整的输出段描述信息如下所示：

section [address] [(type)] : [AT(lma)]
    { 
    	output-section-command
    	output-section-command
    	...
    } [>region] [AT>lma region] [:phdr :phdr ...] [=fillexp]

在使用时，我们可以只挑选某些段属性进行设置即可。  
首先，段名字 两边必须有空白符；同时，冒号和花括号也是必须的。输出段描述可以写到一行中。  
内部的每个output-section-command可以是以下几种之一：

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

### 输出段名称 ###

输出段的名字必须符合输出格式的规范。对于那些只支持有限段的格式，比如a.out格式（a.out格式只支持.text、.data、.bss段），我们就只能使用这些有限的段名。  
需要说明的是，/DISCARD/也是一个输出段名。这个段是有特殊功能的。下文会详细解释。

### 输出段地址 ###

冒号前的这个地址是输出段的VMA（virtual memory address）。如果我们不提供该地址，那么链接器会将该输出段的VMA设置为地址计数器的当前值，或者是对齐值。如果我们提供了该地址值，那么该输出段的地址会被严格地设置为指定的地址值。  
如果我们既没有提供地址值，也没有提供区域，那么给输出段的地址会被设置为地址计数器的当前值。如果地址计数器的当前值没有对齐的话，输出段的地址会被设置为往后偏移一段空白，以使得段地址满足对齐要求。  
比如下面这个例子：

.text . : {  *(.text) }

和

.text : {  *(.text) }

这两者有细微的不同之处。对于第一个，.text输出段的地址会被严格设置为当前地址计数器的值；而对于第二个，.text段的地址会被设置为在地址计数器当前值的基础上，按照所有.text输入段中最高的对齐要求对齐后的值。VMA可以是任意的表达式。如果我们想让输出段的地址按照16字节对齐，也就是我们希望段地址的最低4个比特位是0，那么我们可以这样写：

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

之所以可以这样写，是因为ALIGN(10)返回的是地址计数器的当前值按照指定对齐值对齐后的数值。当我们指明一个输出段的地址之后，地址计数器的值就会发生变化。

### 输入段描述 ###

最常见、最基本的output-section-command就是输入段描述了。

SECTIONS { 
    	.text : {  *(.text) }
    	.DATA : {  [A-Z]*(.data) }
    	.data : {  *(.data) }
    	.bss : {  *(.bss) }
    }

#### 输入段之基础 ####

*(.text)

这里\*表示匹配任意的文件名。如果我们想要排除一些输入文件，则需要使用如下形式：

(*(EXCLUDE_FILE (*crtend.o *otherfile.o) .ctors))

如果我们只想包含某一个特定文件中的某个输入段，那么我们可以这样写：

data.o(.data)

### 输出段的加载内存地址LMA ###

通常情况下LMA和VMA是相等的。但是我们可以使用AT关键字来更改LMA的值。注意，地址计数器的值是VMA。

SECTIONS
    { 
    	.text 0x1000 : {  *(.text) _etext = . ; }
    	.mdata 0x2000 :
    	AT ( ADDR (.text) + SIZEOF (.text) )
    	{  _data = . ; *(.data); _edata = . ; }
    	.bss 0x3000 :
    	{  _bstart = . ; *(.bss) *(COMMON) ; _bend = . ;}
    }

如上例所示，该链接脚本创建了三个输出段.text、.mdata和.bss段。.text段起始于0x1000，而.mdata段在加载时紧挨着.text段，即使.mdata段的VMA是0x2000，而.bss段则位于0x3000。  
\_data的值是0x2000，存储的是VMA的值。

## 常用内置函数 ##

### ABSOLUTE(exp) ###

转换成绝对值

### ADDR(SECTION) ###

返回某section的VMA值

### ALIGN(EXP) ###

返回地址计数器’.'的按照EXP表达式进行对齐后的修调值，对齐后的修调值算法为：(. + EXP – 1) & ~(EXP – 1)。  
ALIGN函数不改变地址计数器的值

### BLOCK(EXP) ###

如同ALIGN(EXP)，为了向前兼容

### DEFINED(SYMBOL) ###

如果符号SYMBOL在全局符号表内，且被定义了，那么返回1，否则返回0

SECTIONS {  ...
    	.text : { 
    	begin = DEFINED(begin) ? begin : . ;
    	...
    	}
    	...
    }

### LOADADDR(SECTION) ###

返回SECTION的LMA

### MAX(EXP1,EXP2) ###

返回大者

### MIN(EXP1,EXP2) ###

返回小者

### NEXT(EXP) ###

返回下一个能被使用的地址，该地址是EXP的倍数，类似于ALIGN(EXP)。除非使用了MEMORY命令定义了一些非连续的内存块，否则NEXT(EXP)与ALIGH(EXP)一定相同

### SIZEOF(SECTION) ###

返回SECTION的大小。当SECTION没有被分配时，即此时SECTION的大小还不能确定时，连接器会报错

SECTIONS{  ...
    	.output { 
    		.start = . ;
    		...
    		.end = . ;
    	}
    	symbol_1 = .end - .start ;
    	symbol_2 = SIZEOF(.output);
    ... }

这个例子中，symbol\_1和symbol\_2的值完全相同。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200212150804581.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200212151443965.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200212152417300.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200212152847225.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200212172451860.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70
[20200213143003831.jpg]: https://img-blog.csdnimg.cn/20200213143003831.jpg
[20200213143254840.jpg]: https://img-blog.csdnimg.cn/20200213143254840.jpg
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200213111719280.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200213111702874.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70