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 (NOLOAD) : {
  37                 __earlybss_start = .;
  38                 *(.earlybss)
  39                 __earlybss_end = .;
  40         }
  41         __earlybss_len = ABSOLUTE(__earlybss_end) - ABSOLUTE(__earlybss_start);
  42         __earlybss_dwords = (__earlybss_len + 3) >> 2;
  43
  44         . = ALIGN(4);
  45         .bss16 (NOLOAD) : {
  46                 __bss16_start = .;
  47                 *(.bss16)
  48                 __bss16_end = .;
  49         }
  50         __bss16_len = ABSOLUTE(__bss16_end) - ABSOLUTE(__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 = ABSOLUTE(__config_end) - ABSOLUTE(__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 = ABSOLUTE(__replacestub_end) - ABSOLUTE(__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 = ABSOLUTE(__gentextnr_end) - ABSOLUTE(__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 = ABSOLUTE(__stack16_end) - ABSOLUTE(__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 = ABSOLUTE(__init_end) - ABSOLUTE(__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 = ABSOLUTE(__text16_end) - ABSOLUTE(__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 = ABSOLUTE(__textnr_end) - ABSOLUTE(__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 = ABSOLUTE(__bcopyxx_text_end) - ABSOLUTE(__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 = ABSOLUTE(__bcopyxx_data_end) - ABSOLUTE(__bcopyxx_data_start);
 145         __bcopyxx_data_dwords = (__bcopyxx_data_len + 3) >> 2;
 146
 147         __bcopyxx_end = .;
 148         __bcopyxx_len = ABSOLUTE(__bcopyxx_end) - ABSOLUTE(__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 = ABSOLUTE(__data16_end) - ABSOLUTE(__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 = ABSOLUTE(__adv_end) - ABSOLUTE(__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 = ABSOLUTE(__uibss_end) - ABSOLUTE(__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          * Used to allocate lowmem buffers from 32-bit code
 216          */
 217         .lowmem (NOLOAD) : {
 218                 __lowmem_start = .;
 219                 *(.lowmem)
 220                 __lowmem_end = .;
 221         }
 222         __lowmem_len = ABSOLUTE(__lowmem_end) - ABSOLUTE(__lowmem_start);
 223         __lowmem_dwords = (__lowmem_len + 3) >> 2;
 224
 225         __high_clear_end = .;
 226
 227         __high_clear_len = ABSOLUTE(__high_clear_end) - ABSOLUTE(__high_clear_start);
 228         __high_clear_dwords = (__high_clear_len + 3) >> 2;
 229
 230         /* Start of the lowmem heap */
 231         . = ALIGN(16);
 232         __lowmem_heap = .;
 233
 234         /*
 235          * 32-bit code.  This is a hack for the moment due to the
 236          * real-mode segments also allocated.
 237          */
 238
 239         . = 0x100000;
 240
 241         __pm_code_start = .;
 242
 243         __text_vma = .;
 244         __text_lma = __pm_code_lma;
 245         .text : AT(__text_lma) {
 246                 FILL(0x90909090)
 247                 __text_start = .;
 248                 *(.text)
 249                 *(.text.*)
 250                 __text_end = .;
 251         }
 252
 253         . = ALIGN(16);
 254
 255         __rodata_vma = .;
 256         __rodata_lma = __rodata_vma + __text_lma - __text_vma;
 257         .rodata : AT(__rodata_lma) {
 258                 __rodata_start = .;
 259                 *(.rodata)
 260                 *(.rodata.*)
 261                 __rodata_end = .;
 262         }
 263
 264         . = ALIGN(4);
 265
 266         __ctors_vma = .;
 267         __ctors_lma = __ctors_vma + __text_lma - __text_vma;
 268         .ctors : AT(__ctors_lma) {
 269                 __ctors_start = .;
 270                 KEEP (*(SORT(.preinit_array*)))
 271                 KEEP (*(SORT(.init_array*)))
 272                 KEEP (*(SORT(.ctors*)))
 273                 __ctors_end = .;
 274         }
 275
 276         __dtors_vma = .;
 277         __dtors_lma = __dtors_vma + __text_lma - __text_vma;
 278         .dtors : AT(__dtors_lma) {
 279                 __dtors_start = .;
 280                 KEEP (*(SORT(.fini_array*)))
 281                 KEEP (*(SORT(.dtors*)))
 282                 __dtors_end = .;
 283         }
 284
 285         . = ALIGN(4);
 286
 287         __dynsym_vma = .;
 288         __dynsym_lma = __dynsym_vma + __text_lma - __text_vma;
 289         .dynsym : AT(__dynsym_lma) {
 290                 __dynsym_start = .;
 291                 *(.dynsym)
 292                 __dynsym_end = .;
 293         }
 294         __dynsym_len = __dynsym_end - __dynsym_start;
 295
 296         . = ALIGN(4);
 297
 298         __dynstr_vma = .;
 299         __dynstr_lma = __dynstr_vma + __text_lma - __text_vma;
 300         .dynstr : AT(__dynstr_lma) {
 301                 __dynstr_start = .;
 302                 *(.dynstr)
 303                 __dynstr_end = .;
 304         }
 305         __dynstr_len = __dynstr_end - __dynstr_start;
 306
 307         . = ALIGN(4);
 308
 309         __gnu_hash_vma = .;
 310         __gnu_hash_lma = __gnu_hash_vma + __text_lma - __text_vma;
 311         .gnu.hash : AT(__gnu_hash_lma) {
 312                 __gnu_hash_start = .;
 313                 *(.gnu.hash)
 314                 __gnu_hash_end = .;
 315         }
 316
 317
 318         . = ALIGN(4);
 319
 320         __dynlink_vma = .;
 321         __dynlink_lma = __dynlink_vma + __text_lma - __text_vma;
 322         .dynlink : AT(__dynlink_lma) {
 323                 __dynlink_start = .;
 324                 *(.dynlink)
 325                 __dynlink_end = .;
 326         }
 327
 328         . = ALIGN(4);
 329
 330         __got_vma = .;
 331         __got_lma = __got_vma + __text_lma - __text_vma;
 332         .got : AT(__got_lma) {
 333                 __got_start = .;
 334                 KEEP (*(.got.plt))
 335                 KEEP (*(.got))
 336                 __got_end = .;
 337         }
 338
 339         . = ALIGN(4);
 340
 341         __dynamic_vma = .;
 342         __dynamic_lma = __dynamic_vma + __text_lma - __text_vma;
 343         .dynamic : AT(__dynamic_lma) {
 344                 __dynamic_start = .;
 345                 *(.dynamic)
 346                 __dynamic_end = .;
 347         }
 348
 349         . = ALIGN(16);
 350
 351         __data_vma = .;
 352         __data_lma = __data_vma + __text_lma - __text_vma;
 353         .data : AT(__data_lma) {
 354                 __data_start = .;
 355                 *(.data)
 356                 *(.data.*)
 357                 __data_end = .;
 358         }
 359
 360         __pm_code_end = .;
 361         __pm_code_len = ABSOLUTE(__pm_code_end) - ABSOLUTE(__pm_code_start);
 362         __pm_code_dwords = (__pm_code_len + 3) >> 2;
 363
 364         . = ALIGN(128);
 365
 366         __bss_vma = .;
 367         __bss_lma = .;          /* Dummy */
 368         .bss (NOLOAD) : AT (__bss_lma) {
 369                 __bss_start = .;
 370                 *(.bss)
 371                 *(.bss.*)
 372                 *(COMMON)
 373                 __bss_end = .;
 374         }
 375         __bss_len = ABSOLUTE(__bss_end) - ABSOLUTE(__bss_start);
 376         __bss_dwords = (__bss_len + 3) >> 2;
 377
 378         /* Very large objects which don't need to be zeroed */
 379
 380         . = ALIGN(128);
 381
 382         __hugebss_vma = .;
 383         __hugebss_lma = .;              /* Dummy */
 384         .hugebss (NOLOAD) : AT (__hugebss_lma) {
 385                 __hugebss_start = .;
 386                 *(.hugebss)
 387                 *(.hugebss.*)
 388                 __hugebss_end = .;
 389         }
 390         __hugebss_len = ABSOLUTE(__hugebss_end) - ABSOLUTE(__hugebss_start);
 391         __hugebss_dwords = (__hugebss_len + 3) >> 2;
 392
 393         /* Data saved away before bss initialization */
 394         . = ALIGN(128);
 395
 396         __savedata_vma = .;
 397         __savedata_lma = .;             /* Dummy */
 398         .savedata (NOLOAD) : AT (__savedata_lma) {
 399                 __savedata_start = .;
 400                 *(.savedata)
 401                 *(.savedata.*)
 402                 __savedata_end = .;
 403         }
 404         __savedata_len = ABSOLUTE(__savedata_end) - ABSOLUTE(__savedata_start);
 405         __savedata_dwords = (__savedata_len + 3) >> 2;
 406
 407         /* XXX: This stack should be unified with the COM32 stack */
 408         __stack_vma = .;
 409         __stack_lma = .;        /* Dummy */
 410         .stack (NOLOAD) : AT(__stack_lma) {
 411                 __stack_start = .;
 412                 *(.stack)
 413                 __stack_end = .;
 414         }
 415         __stack_len = ABSOLUTE(__stack_end) - ABSOLUTE(__stack_start);
 416         __stack_dwords = (__stack_len + 3) >> 2;
 417
 418         _end = .;
 419
 420         /* COM32R and kernels are loaded after our own PM code */
 421         . = ALIGN(65536);
 422         free_high_memory = .;
 423
 424         /* Stuff we don't need... */
 425         /DISCARD/ : {
 426                 *(.eh_frame)
 427         }
 428 }