core/syslinux.ld

   1 /* -----------------------------------------------------------------------
   2  *
   3  *   Copyright 2008-2009 H. Peter Anvin - All Rights Reserved
   4  *   Copyright 2009 Intel Corporation; author: H. Peter Anvin
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
   9  *   Boston MA 02110-1301, USA; either version 2 of the License, or
  10  *   (at your option) any later version; incorporated herein by reference.
  11  *
  12  * ----------------------------------------------------------------------- */
  13
  14 /*
  15  * Linker script for the SYSLINUX core
  16  */
  17
  18 OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
  19 OUTPUT_ARCH(i386)
  20 EXTERN(_start)
  21 ENTRY(_start)
  22
  23 STACK32_LEN = 65536;
  24
  25 SECTIONS
  26 {
  27         /* Prefix structure for the compression program */
  28         . = 0;
  29         .prefix : {
  30                 *(.prefix)
  31         }
  32
  33         /* "Early" sections (before the load) */
  34         . = 0x1000;
  35
  36         .earlybss : {
  37                 __earlybss_start = .;
  38                 *(.earlybss)
  39                 __earlybss_end = .;
  40         }
  41         __earlybss_len = __earlybss_end - __earlybss_start;
  42         __earlybss_dwords = (__earlybss_len + 3) >> 2;
  43
  44         . = ALIGN(4);
  45         .bss16 : {
  46                 __bss16_start = .;
  47                 *(.bss16)
  48                 __bss16_end = .;
  49         }
  50         __bss16_len = __bss16_end - __bss16_start;
  51         __bss16_dwords = (__bss16_len + 3) >> 2;
  52
  53         . = ALIGN(4);
  54         .config : AT (__config_lma) {
  55                 __config_start = .;
  56                 *(.config)
  57                 __config_end = .;
  58         }
  59         __config_len = __config_end - __config_start;
  60         __config_dwords = (__config_len + 3) >> 2;
  61
  62         /* Generated and/or copied code */
  63
  64         . = ALIGN(128);         /* Minimum separation from mutable data */
  65         .replacestub : AT (__replacestub_lma) {
  66                 __replacestub_start = .;
  67                 *(.replacestub)
  68                 __replacestub_end = .;
  69         }
  70         __replacestub_len = __replacestub_end - __replacestub_start;
  71         __replacestub_dwords = (__replacestub_len + 3) >> 2;
  72
  73         . = ALIGN(16);
  74         __gentextnr_lma = .;
  75         .gentextnr : AT(__gentextnr_lma) {
  76                 __gentextnr_start = .;
  77                 *(.gentextnr)
  78                 __gentextnr_end = .;
  79         }
  80         __gentextnr_len = __gentextnr_end - __gentextnr_start;
  81         __gentextnr_dwords = (__gentextnr_len + 3) >> 2;
  82
  83         . = STACK_BASE;
  84         .stack16 : AT(STACK_BASE) {
  85                 __stack16_start = .;
  86                 . += STACK_LEN;
  87                 __stack16_end = .;
  88         }
  89         __stack16_len = __stack16_end - __stack16_start;
  90         __stack16_dwords = (__stack16_len + 3) >> 2;
  91
  92         /* Initialized sections */
  93
  94         . = 0x7c00;
  95         .init : {
  96                 FILL(0x90909090)
  97                 __init_start = .;
  98                 *(.init)
  99                 __init_end = .;
 100         }
 101         __init_len = __init_end - __init_start;
 102         __init_dwords = (__init_len + 3) >> 2;
 103
 104         .text16 : {
 105                 FILL(0x90909090)
 106                 __text16_start = .;
 107                 *(.text16)
 108                 __text16_end = .;
 109         }
 110         __text16_len = __text16_end - __text16_start;
 111         __text16_dwords = (__text16_len + 3) >> 2;
 112
 113         /*
 114          * .textnr is used for 32-bit code that is used on the code
 115          * path to initialize the .text segment
 116          */
 117         . = ALIGN(16);
 118         .textnr : {
 119                 FILL(0x90909090)
 120                 __textnr_start = .;
 121                 *(.textnr)
 122                 __textnr_end = .;
 123         }
 124         __textnr_len = __textnr_end - __textnr_start;
 125         __textnr_dwords = (__textnr_len + 3) >> 2;
 126
 127         . = ALIGN(16);
 128         __bcopyxx_start = .;
 129
 130         .bcopyxx.text : {
 131                 FILL(0x90909090)
 132                 __bcopyxx_text_start = .;
 133                 *(.bcopyxx.text)
 134                 __bcopyxx_text_end = .;
 135         }
 136         __bcopyxx_text_len = __bcopyxx_text_end - __bcopyxx_text_start;
 137         __bcopyxx_text_dwords = (__bcopyxx_text_len + 3) >> 2;
 138
 139         .bcopyxx.data : {
 140                 __bcopyxx_data_start = .;
 141                 *(.bcopyxx.text)
 142                 __bcopyxx_data_end = .;
 143         }
 144         __bcopyxx_data_len = __bcopyxx_data_end - __bcopyxx_data_start;
 145         __bcopyxx_data_dwords = (__bcopyxx_data_len + 3) >> 2;
 146
 147         __bcopyxx_end = .;
 148         __bcopyxx_len = __bcopyxx_end - __bcopyxx_start;
 149         __bcopyxx_dwords = (__bcopyxx_len + 3) >> 2;
 150
 151         . = ALIGN(4);
 152         .data16 : {
 153               __data16_start = .;
 154               *(.data16)
 155               __data16_end = .;
 156         }
 157         __data16_len = __data16_end - __data16_start;
 158         __data16_dwords = (__data16_len + 3) >> 2;
 159
 160         . = ALIGN(4);
 161         __config_lma = .;
 162         . += SIZEOF(.config);
 163
 164         . = ALIGN(4);
 165         __replacestub_lma = .;
 166         . += SIZEOF(.replacestub);
 167
 168         /* The 32-bit code loads above the non-progbits sections */
 169
 170         . = ALIGN(16);
 171         __pm_code_lma = .;
 172
 173         __high_clear_start = .;
 174
 175         . = ALIGN(512);
 176         .adv (NOLOAD) : {
 177                 __adv_start = .;
 178                 *(.adv)
 179                 __adv_end = .;
 180         }
 181         __adv_len = __adv_end - __adv_start;
 182         __adv_dwords = (__adv_len + 3) >> 2;
 183
 184         /* Late uninitialized sections */
 185
 186         . = ALIGN(4);
 187         .uibss (NOLOAD) : {
 188                 __uibss_start = .;
 189                 *(.uibss)
 190                 __uibss_end = .;
 191         }
 192         __uibss_len = __uibss_end - __uibss_start;
 193         __uibss_dwords = (__uibss_len + 3) >> 2;
 194
 195         _end16 = .;
 196         __assert_end16 = ASSERT(_end16 <= 0x10000, "64K overflow");
 197
 198         /*
 199          * Special 16-bit segments
 200          */
 201
 202         . = ALIGN(65536);
 203         .real_mode (NOLOAD) : {
 204                 *(.real_mode)
 205         }
 206         real_mode_seg = core_real_mode >> 4;
 207
 208         . = ALIGN(65536);
 209         .xfer_buf (NOLOAD) : {
 210                 *(.xfer_buf)
 211         }
 212         xfer_buf_seg = core_xfer_buf >> 4;
 213
 214         /*
 215          * The auxilliary data segment is used by the 16-bit code
 216          * for items that don't need to live in the bottom 64K.
 217          */
 218
 219         . = ALIGN(16);
 220         .auxseg (NOLOAD) : {
 221                 __auxseg_start = .;
 222                 *(.auxseg)
 223                 __auxseg_end = .;
 224         }
 225         __auxseg_len = __auxseg_end - __auxseg_start;
 226         __auxseg_dwords = (__auxseg_len + 3) >> 2;
 227         aux_seg = __auxseg_start >> 4;
 228
 229         /*
 230          * Used to allocate lowmem buffers from 32-bit code
 231          */
 232         .lowmem (NOLOAD) : {
 233                 __lowmem_start = .;
 234                 *(.lowmem)
 235                 __lowmem_end = .;
 236         }
 237         __lowmem_len = __lowmem_end - __lowmem_start;
 238         __lowmem_dwords = (__lowmem_len + 3) >> 2;
 239
 240         __high_clear_end = .;
 241
 242         __high_clear_len = __high_clear_end - __high_clear_start;
 243         __high_clear_dwords = (__high_clear_len + 3) >> 2;
 244
 245         /* Start of the lowmem heap */
 246         . = ALIGN(16);
 247         __lowmem_heap = .;
 248
 249         /*
 250          * 32-bit code.  This is a hack for the moment due to the
 251          * real-mode segments also allocated.
 252          */
 253
 254         . = 0x100000;
 255
 256         __pm_code_start = .;
 257
 258         __text_vma = .;
 259         __text_lma = __pm_code_lma;
 260         .text : AT(__text_lma) {
 261                 FILL(0x90909090)
 262                 __text_start = .;
 263                 *(.text)
 264                 *(.text.*)
 265                 __text_end = .;
 266         }
 267
 268         . = ALIGN(16);
 269
 270         __rodata_vma = .;
 271         __rodata_lma = __rodata_vma + __text_lma - __text_vma;
 272         .rodata : AT(__rodata_lma) {
 273                 __rodata_start = .;
 274                 *(.rodata)
 275                 *(.rodata.*)
 276                 __rodata_end = .;
 277         }
 278
 279         . = ALIGN(4);
 280
 281         __ctors_vma = .;
 282         __ctors_lma = __ctors_vma + __text_lma - __text_vma;
 283         .ctors : AT(__ctors_lma) {
 284                 __ctors_start = .;
 285                 KEEP (*(SORT(.ctors.*)))
 286                 KEEP (*(.ctors))
 287                 __ctors_end = .;
 288         }
 289
 290         __dtors_vma = .;
 291         __dtors_lma = __dtors_vma + __text_lma - __text_vma;
 292         .dtors : AT(__dtors_lma) {
 293                 __dtors_start = .;
 294                 KEEP (*(SORT(.dtors.*)))
 295                 KEEP (*(.dtors))
 296                 __dtors_end = .;
 297         }
 298
 299         . = ALIGN(4);
 300
 301         __dynlink_vma = .;
 302         __dynlink_lma = __dynlink_vma + __text_lma - __text_vma;
 303         .dynlink : AT(__dynlink_lma) {
 304                 __dynlink_start = .;
 305                 *(.dynlink)
 306                 __dynlink_end = .;
 307         }
 308
 309         . = ALIGN(4);
 310
 311         __got_vma = .;
 312         __got_lma = __got_vma + __text_lma - __text_vma;
 313         .got : AT(__got_lma) {
 314                 __got_start = .;
 315                 KEEP (*(.got.plt))
 316                 KEEP (*(.got))
 317                 __got_end = .;
 318         }
 319
 320         __data_vma = .;
 321         __data_lma = __data_vma + __text_lma - __text_vma;
 322         .data : AT(__data_lma) {
 323                 __data_start = .;
 324                 *(.data)
 325                 *(.data.*)
 326                 __data_end = .;
 327         }
 328
 329         __pm_code_end = .;
 330         __pm_code_len = __pm_code_end - __pm_code_start;
 331         __pm_code_dwords = (__pm_code_len + 3) >> 2;
 332
 333         . = ALIGN(128);
 334
 335         __bss_vma = .;
 336         __bss_lma = .;          /* Dummy */
 337         .bss (NOLOAD) : AT (__bss_lma) {
 338                 __bss_start = .;
 339                 *(.bss)
 340                 *(.bss.*)
 341                 *(COMMON)
 342                 __bss_end = .;
 343         }
 344         __bss_len = __bss_end - __bss_start;
 345         __bss_dwords = (__bss_len + 3) >> 2;
 346
 347         /* Very large objects which don't need to be zeroed */
 348
 349         __hugebss_vma = .;
 350         __hugebss_lma = .;              /* Dummy */
 351         .hugebss (NOLOAD) : AT (__hugebss_lma) {
 352                 __hugebss_start = .;
 353                 *(.hugebss)
 354                 *(.hugebss.*)
 355                 __hugebss_end = .;
 356         }
 357         __hugebss_len = __hugebss_end - __hugebss_start;
 358         __hugebss_dwords = (__hugebss_len + 3) >> 2;
 359
 360
 361         /* XXX: This stack should be unified with the COM32 stack */
 362         __stack_vma = .;
 363         __stack_lma = .;        /* Dummy */
 364         .stack (NOLOAD) : AT(__stack_lma) {
 365                 __stack_start = .;
 366                 *(.stack)
 367                 __stack_end = .;
 368         }
 369         __stack_len = __stack_end - __stack_start;
 370         __stack_dwords = (__stack_len + 3) >> 2;
 371
 372         _end = .;
 373
 374         /* COM32R and kernels are loaded after our own PM code */
 375         . = ALIGN(65536);
 376         free_high_memory = .;
 377
 378         /* Stuff we don't need... */
 379         /DISCARD/ : {
 380                 *(.eh_frame)
 381         }
 382 }