LD 链接器脚本

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

MEMORY
{
    FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 1M
    SRAM (rwx) : ORIGIN = 0x20000000, LENGTH = 128K
}

/* 定义通用别名 */
REGION_ALIAS("REGION_TEXT"   , FLASH);
REGION_ALIAS("REGION_RODATA" , FLASH);
REGION_ALIAS("REGION_DATA"   , SRAM);
REGION_ALIAS("REGION_BSS"    , SRAM);

SECTIONS
{
    .text   : { *(.text)   } > REGION_TEXT
    .rodata : { *(.rodata) } > REGION_RODATA
    .data   : { *(.data)   } > REGION_DATA
    .bss    : { *(.bss)    } > REGION_BSS
}

SECTIONS
{
    .text_special : {
        *(.text.special_init)
    }
} INSERT BEFORE .text;    /* 在 .text 之前插入 */

$ ld main.o special.o -T insert_special.ld -o program

$ ld main.o special.o -T my_script.ld -T insert_special.ld -o program

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

SECTIONS
{
    .text : { *(.text) }
    . = 0x20000000;
    .data : {
        _sdata = .;
        *(.data)
        _edata = .;
    }
}

$ objdump -t target.elf
[地址]    [标志]    [段]     [大小]    [符号名]
20000000  g         .data    00000000  _sdata
20000000  g      O  .data    00000004  count
20000004  g         .data    00000000  _edata

extern int _sdata;
int *p = &_sdata;

extern int _sdata[];
int *p = _sdata;

ldr  r0, =_sdata    /* r0 = 0x20000000 */

/DISCARD/ : {
    *(.debug*)    /* 丢弃所有调试信息段 */
}

.text   : { *(.text) }            /* 段名后面没有指定地址，链接器会自动使用当前 '.' 的值作为 VMA                                           */
.text . : { *(.text) }            /* 显式指定 VMA = 当前的 '.' 值                                                                          */
.text 0x08000000  : { *(.text) }  /* 指定 VMA = 0x08000000                                                                                 */
.text ALIGN(0x10) : { *(.text) }  /* 将 VMA 对齐到 0x10 字节边界，使得地址的最低四位为零，ALIGN 返回当前定位计数器向上对齐到指定值后的结果 */

.debug_info (NOLOAD) : {
    *(.debug_info)
    *(.debug_line)
}

.text . (TYPE = SHT_PROGBITS) : { *(.text) }

$ readelf -S target.elf
Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .isr_vector       PROGBITS        08000000 001000 0001e4 00   A  0   0  1
  [ 2] .text             PROGBITS        080001e4 0011e4 00059c 00  AX  0   0  4

.data . : AT(0x20000000) { *(.data) }

.data . : ALIGN(4) { *(.data) }    /* .bss 段起始地址 4 字节对齐 */

.text : SUBALIGN(4) {
    *(.text.func1)    /* 强制 4 字节对齐 */
    *(.text.func2)    /* 强制 4 字节对齐 */
    *(.text.func3)    /* 强制 4 字节对齐 */
}

.text : SUBALIGN(4) {
    *(.text.*)        /* 匹配的 .text.func1 ， .text.func2 ， ... 都强制 4 字节对齐 */
}

.data : {
    *(.data)
}
.data1 : {
    data.o(.data)    /* 如果 data.o 存在，该规则不会被使用 */
}

.text : {
    EXCLUDE_FILE (*debug.o *info.o) *(.text)    /* 匹配除 debug.o 和 info.o 之外的所有文件 */
    *(EXCLUDE_FILE (*debug.o *info.o) .text)    /* 另一种写法                              */
}

.text : {
    *(.text .rodata)       /* .text 与 .rodata 会在输出段中交错显示    */
    *(.text) *(.rodata)    /* .text 在输出段中先出现，然后才是 .rodata */
}

.text : {
    EXCLUDE_FILE (*somefile.o) *(.text .rodata)
    *(EXCLUDE_FILE (*somefile.o) .text EXCLUDE_FILE (*somefile.o) .rodata)
}

.text : {
    *(EXCLUDE_FILE (*somefile.o) .text .rodata)    /* 对 .rodata 不生效，仍旧会匹配 *somefile.o 中的 .rodata */
}

.text : {
    INPUT_SECTION_FLAGS (SHF_MERGE & SHF_STRINGS) *(.text)    /* 标志位 SHF_MERGE 和 SHF_STRINGS 被设置的段 */
}
.text2 : {
    INPUT_SECTION_FLAGS (!SHF_WRITE) *(.text)                 /* 标志位 SHF_WRITE 未设置的段                */
}

$ readelf -S target.elf
Section Headers:                                                    ↓
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .isr_vector       PROGBITS        08000000 001000 0001e4 00   A  0   0  1
  [ 2] .text             PROGBITS        080001e4 0011e4 00059c 00  AX  0   0  4

.text : {
    libc.a:         (.text)    /* 匹配 libc.a 文件中的所有 .text 段               */
    libc.a:printf.o (.text)    /* 匹配 libc.a 文件中的 printf.o 中的所有 .text 段 */
          :printf.o (.text)    /* 匹配非静态库文件中的 printf.o 中的所有 .text 段 */
           printf.o            /* 匹配 printf.o 中所有段                          */
}

.text : {
    *(SORT_BY_NAME(.text*))
}

.text : {
    *(SORT_BY_ALIGNMENT(.text*))
}

.text : {
    *(SORT_BY_INIT_PRIORITY(.init_array*))
}

.text : {
    *(REVERSE(.text*))                  /* 按名称升序排序，效果等同 SORT_BY_NAME */
    *(REVERSE(SORT_BY_NAME(.text*)))    /* 按名称降序排序                        */
}

.text : {
    *(REVERSE(.text* .init*))    /* 无法正常工作 */
}

.text : {
    *(SORT_BY_NAME (SORT_BY_ALIGNMENT (.text*)))         /* 先按名称升序，如果有两个段名称排序相同，这两个段再按对齐降序 */
    *(SORT_BY_ALIGNMENT (SORT_BY_NAME (.text*)))         /* 先按对齐降序，如果有两个段对齐排序相同，这两个段再按名称升序 */
    *(SORT_BY_NAME (SORT_BY_NAME (.text*)))              /* 按名称升序，同 SORT_BY_NAME                                  */
    *(SORT_BY_ALIGNMENT (SORT_BY_ALIGNMENT (.text*)))    /* 按对齐降序，同 SORT_BY_ALIGNMENT                             */
    *(SORT_BY_NAME (REVERSE (.text*)))                   /* 按名称降序                                                   */
    *(REVERSE (SORT_BY_NAME (.text*)))                   /* 按名称降序                                                   */
    *(SORT_BY_INIT_PRIORITY (REVERSE (.init_array*)))    /* 按优先级降序                                                 */
}

.text : {
    KEEP(*(.init))
}

.text : {
    BYTE(1)              /* 存储 1 ，大小一字节            */
    LONG(addr)           /* 存储符号 addr 的四字节值       */
    LONG(0x12345678);    /* 存储 0x12345678 这个四字节数据 */
}

.rodata : {
    ASCIZ "This is 16 bytes"    /* 这个包含 16 个字符的字符串将创建一个 17 字节的区域 */
}

.text : {
    FILL(144)              /* 144 = 0x90 ， 扩展为 00 00 00 90                   */
    FILL(22 * 256 + 23)    /* 22 * 256 + 23 = 5665 = 0x1617 ，扩展为 00 00 16 17 */
}

.text : {
    FILL(0x90)            /* 用 90 循环填充             */
    FILL(0x0090)          /* 用 00 90 循环填充          */
    FILL(0x123456789a)    /* 用 12 34 56 78 9a 循环填充 */
}

MEMORY {
    rom : ORIGIN = 0x1000, LENGTH = 0x1000
}
SECTIONS {
    ROM : {
        *(.text)
    } >rom
}

PHDRS {
    text PT_LOAD ;
}
SECTIONS {
    .text : {
        *(.text)
    } :text
}

.text : {
    *(.text)
} =0x90909090

SECTIONS
{
    OVERLAY 0x2000 : AT (0x1000)
    {
        .text0 { driver_a.o(.text) }
        .text1 { driver_b.o(.text) }
    }
}

extern char  __load_start_text0[],  __load_stop_text0[],  __load_start_text1[],  __load_stop_text1[];

void use_driver_a(void) {
    memcpy ((char *) 0x2000,  __load_start_text0,  __load_stop_text0 - __load_start_text0);    /* 加载驱动程序 A */
    driver_a_init();    /* 调用 driver A 的函数 */
}

void use_driver_b(void) {
    memcpy ((char *) 0x2000,  __load_start_text1,  __load_stop_text1 - __load_start_text1);    /* 加载驱动程序 B */
    driver_b_init();  /* 调用 driver B 的函数 */
}

SECTIONS
{
    .text0 0x2000 : AT (0x1000) { driver_a.o(.text) }
    PROVIDE (__load_start_text0 = LOADADDR (.text0));
    PROVIDE (__load_stop_text0  = LOADADDR (.text0) + SIZEOF (.text0));

    .text1 0x2000 : AT (0x1000 + SIZEOF (.text0)) { driver_b.o(.text) }
    PROVIDE (__load_start_text1 = LOADADDR (.text1));
    PROVIDE (__load_stop_text1  = LOADADDR (.text1) + SIZEOF (.text1));

    . = 0x2000 + MAX (SIZEOF (.text0), SIZEOF (.text1));
}

MEMORY
{
    rom (rx)  : ORIGIN = 0, LENGTH = 256K
    ram (!rx) : org = 0x40000000, l = 4M
}

PHDRS
{
    headers PT_PHDR PHDRS ;
    interp  PT_INTERP ;
    text    PT_LOAD FILEHDR PHDRS ;
    data    PT_LOAD ;
    dynamic PT_DYNAMIC ;
}

SECTIONS
{
    . = SIZEOF_HEADERS;
    .interp  : { *(.interp) } :text :interp
    .text    : { *(.text)   } :text
    .rodata  : { *(.rodata) }
    ...
    . = . + 0x1000;
    .data    : { *(.data)    } :data
    .dynamic : { *(.dynamic) } :data :dynamic
    ...
}

.text ALIGN (CONSTANT (MAXPAGESIZE)) : { *(.text) }

SECTIONS
{
    . = 0x100;         /* VMA = 0x100 绝对地址                                                           */
    .text: {
        . = 0x80;      /* 相对地址，相对 .text 起始偏移 0x80 -> 0x100 + 0x80                             */
        *(.text)
        . = 0x200;     /* 不论 *(.text) 多大，.text 的结束地址为 0x100 + 0x200 ，即 .text 固定大小 0x200 */
    }
    . = 0x500;         /* VMA = 0x500 绝对地址                                                           */
    .data: {
        . = 0x80;      /* 相对地址，相对 .data 起始偏移 0x80 -> 0x500 + 0x80                             */
        *(.data)
        . += 0x600;    /* . = . + 0x600  ->  . = (0x80 + *(.data)) + 0x600                               */
    }
}

SECTIONS
{
    . = 0x1000;
    .text : {
        _stext0 = 0x200;              /* _stext0 = 0x1000 + 0x200 */
        _stext1 = ABSOLUTE(0x200);    /* _stext1 = 0x200          */
        *(.text)
    }
}

. = 0x100
.text : {
    . = ALIGN(0x11,4);    /* . 相对 .text 起始偏移为 0 ，ALIGN 从 0x11 开始对齐（返回 0x14），对齐后 0x114 */
    *(.text)
}
. = 0x200
.data : {
    . = ALIGN(4);         /* . 相对 .data 起始偏移为 0 ，ALIGN 从 0 开始对齐（返回 0），对齐后 0x200 */
    *(.data)
}

SECTIONS
{
    . = 0x0;
    .text : {
        *(.text)
        . = 0x2800;
    }
    . = DATA_SEGMENT_ALIGN(0x4000, 0x1000);
    .data : {
        *(.data)
        . = 0x1000;
    }
    . = DATA_SEGMENT_END(.);
}

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

MEMORY
{
    RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 64K
    FLASH (rx)     : ORIGIN = 0x8000000, LENGTH = 512K
}
_estack = ORIGIN(RAM) + LENGTH(RAM);

_sidata = LOADADDR(.data);

.data : {
    . = ALIGN(1 << LOG2CEIL(100));    /* LOG2CEIL(100) = 7 ，1 << 7 对齐到 128 字节 */
}

SECTIONS
{
    . = SEGMENT_START("text", 0x1000);
    text : {
        _stext = . ;
        *(.text)
    }
}

SECTIONS
{
    _size = SIZEOF_HEADERS ;
    ...
}

$ objdump -t target.elf | grep _size
00000094 g       *ABS*	00000000 _size
$ readelf -h target.elf
ELF Header:
  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF32
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           ARM
  Version:                           0x1
  Entry point address:               0x8000271
  Start of program headers:          52 (bytes into file)
  Start of section headers:          76864 (bytes into file)
  Flags:                             0x5000200, Version5 EABI, soft-float ABI
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         3
  Size of section headers:           40 (bytes)
  Number of section headers:         22
  Section header string table index: 21