core/x86_64/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("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
  19 OUTPUT_ARCH(i386:x86-64)
  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         __module_start = .;
  30         .prefix : {
  31                 *(.prefix)
  32         }
  33
  34         /* "Early" sections (before the load) */
  35         . = 0x1000;
  36
  37         .earlybss (NOLOAD) : {
  38                 __earlybss_start = .;
  39                 *(.earlybss)
  40                 __earlybss_end = .;
  41         }
  42         __earlybss_len = ABSOLUTE(__earlybss_end) - ABSOLUTE(__earlybss_start);
  43         __earlybss_dwords = (__earlybss_len + 3) >> 2;
  44
  45         . = ALIGN(4);
  46         .bss16 (NOLOAD) : {
  47                 __bss16_start = .;
  48                 *(.bss16)
  49                 __bss16_end = .;
  50         }
  51         __bss16_len = ABSOLUTE(__bss16_end) - ABSOLUTE(__bss16_start);
  52         __bss16_dwords = (__bss16_len + 3) >> 2;
  53
  54         . = ALIGN(4);
  55         .config : AT (__config_lma) {
  56                 __config_start = .;
  57                 *(.config)
  58                 __config_end = .;
  59         }
  60         __config_len = ABSOLUTE(__config_end) - ABSOLUTE(__config_start);
  61         __config_dwords = (__config_len + 3) >> 2;
  62
  63         /* Generated and/or copied code */
  64
  65         . = ALIGN(128);         /* Minimum separation from mutable data */
  66         .replacestub : AT (__replacestub_lma) {
  67                 __replacestub_start = .;
  68                 *(.replacestub)
  69                 __replacestub_end = .;
  70         }
  71         __replacestub_len = ABSOLUTE(__replacestub_end) - ABSOLUTE(__replacestub_start);
  72         __replacestub_dwords = (__replacestub_len + 3) >> 2;
  73
  74         . = ALIGN(16);
  75         __gentextnr_lma = .;
  76         .gentextnr : AT(__gentextnr_lma) {
  77                 __gentextnr_start = .;
  78                 *(.gentextnr)
  79                 __gentextnr_end = .;
  80         }
  81         __gentextnr_len = ABSOLUTE(__gentextnr_end) - ABSOLUTE(__gentextnr_start);
  82         __gentextnr_dwords = (__gentextnr_len + 3) >> 2;
  83
  84         . = STACK_BASE;
  85         .stack16 : AT(STACK_BASE) {
  86                 __stack16_start = .;
  87                 . += STACK_LEN;
  88                 __stack16_end = .;
  89         }
  90         __stack16_len = ABSOLUTE(__stack16_end) - ABSOLUTE(__stack16_start);
  91         __stack16_dwords = (__stack16_len + 3) >> 2;
  92
  93         /* Initialized sections */
  94
  95         . = 0x7c00;
  96         .init : {
  97                 FILL(0x90909090)
  98                 __init_start = .;
  99                 *(.init)
 100                 __init_end = .;
 101         }
 102         __init_len = ABSOLUTE(__init_end) - ABSOLUTE(__init_start);
 103         __init_dwords = (__init_len + 3) >> 2;
 104
 105         .text16 : {
 106                 FILL(0x90909090)
 107                 __text16_start = .;
 108                 *(.text16)
 109                 __text16_end = .;
 110         }
 111         __text16_len = ABSOLUTE(__text16_end) - ABSOLUTE(__text16_start);
 112         __text16_dwords = (__text16_len + 3) >> 2;
 113
 114         /*
 115          * .textnr is used for 32-bit code that is used on the code
 116          * path to initialize the .text segment
 117          */
 118         . = ALIGN(16);
 119         .textnr : {
 120                 FILL(0x90909090)
 121                 __textnr_start = .;
 122                 *(.textnr)
 123                 __textnr_end = .;
 124         }
 125         __textnr_len = ABSOLUTE(__textnr_end) - ABSOLUTE(__textnr_start);
 126         __textnr_dwords = (__textnr_len + 3) >> 2;
 127
 128         . = ALIGN(16);
 129         __bcopyxx_start = .;
 130
 131         .bcopyxx.text : {
 132                 FILL(0x90909090)
 133                 __bcopyxx_text_start = .;
 134                 *(.bcopyxx.text)
 135                 __bcopyxx_text_end = .;
 136         }
 137         __bcopyxx_text_len = ABSOLUTE(__bcopyxx_text_end) - ABSOLUTE(__bcopyxx_text_start);
 138         __bcopyxx_text_dwords = (__bcopyxx_text_len + 3) >> 2;
 139
 140         .bcopyxx.data : {
 141                 __bcopyxx_data_start = .;
 142                 *(.bcopyxx.text)
 143                 __bcopyxx_data_end = .;
 144         }
 145         __bcopyxx_data_len = ABSOLUTE(__bcopyxx_data_end) - ABSOLUTE(__bcopyxx_data_start);
 146         __bcopyxx_data_dwords = (__bcopyxx_data_len + 3) >> 2;
 147
 148         __bcopyxx_end = .;
 149         __bcopyxx_len = ABSOLUTE(__bcopyxx_end) - ABSOLUTE(__bcopyxx_start);
 150         __bcopyxx_dwords = (__bcopyxx_len + 3) >> 2;
 151
 152         . = ALIGN(4);
 153         .data16 : {
 154               __data16_start = .;
 155               *(.data16)
 156               __data16_end = .;
 157         }
 158         __data16_len = ABSOLUTE(__data16_end) - ABSOLUTE(__data16_start);
 159         __data16_dwords = (__data16_len + 3) >> 2;
 160
 161         . = ALIGN(4);
 162         __config_lma = .;
 163         . += SIZEOF(.config);
 164
 165         . = ALIGN(4);
 166         __replacestub_lma = .;
 167         . += SIZEOF(.replacestub);
 168
 169         /* The 32-bit code loads above the non-progbits sections */
 170
 171         . = ALIGN(16);
 172         __pm_code_lma = .;
 173
 174         __high_clear_start = .;
 175
 176         . = ALIGN(512);
 177         .adv (NOLOAD) : {
 178                 __adv_start = .;
 179                 *(.adv)
 180                 __adv_end = .;
 181         }
 182         __adv_len = ABSOLUTE(__adv_end) - ABSOLUTE(__adv_start);
 183         __adv_dwords = (__adv_len + 3) >> 2;
 184
 185         /* Late uninitialized sections */
 186
 187         . = ALIGN(4);
 188         .uibss (NOLOAD) : {
 189                 __uibss_start = .;
 190                 *(.uibss)
 191                 __uibss_end = .;
 192         }
 193         __uibss_len = ABSOLUTE(__uibss_end) - ABSOLUTE(__uibss_start);
 194         __uibss_dwords = (__uibss_len + 3) >> 2;
 195
 196         _end16 = .;
 197         __assert_end16 = ASSERT(_end16 <= 0x10000, "64K overflow");
 198
 199         /*
 200          * Special 16-bit segments
 201          */
 202
 203         . = ALIGN(65536);
 204         .real_mode (NOLOAD) : {
 205                 *(.real_mode)
 206         }
 207         real_mode_seg = core_real_mode >> 4;
 208
 209         . = ALIGN(65536);
 210         .xfer_buf (NOLOAD) : {
 211                 *(.xfer_buf)
 212         }
 213         xfer_buf_seg = core_xfer_buf >> 4;
 214
 215         /*
 216          * The auxilliary data segment is used by the 16-bit code
 217          * for items that don't need to live in the bottom 64K.
 218          */
 219
 220         . = ALIGN(16);
 221         .auxseg (NOLOAD) : {
 222                 __auxseg_start = .;
 223                 *(.auxseg)
 224                 __auxseg_end = .;
 225         }
 226         __auxseg_len = ABSOLUTE(__auxseg_end) - ABSOLUTE(__auxseg_start);
 227         __auxseg_dwords = (__auxseg_len + 3) >> 2;
 228         aux_seg = __auxseg_start >> 4;
 229
 230         /*
 231          * Used to allocate lowmem buffers from 32-bit code
 232          */
 233         .lowmem (NOLOAD) : {
 234                 __lowmem_start = .;
 235                 *(.lowmem)
 236                 __lowmem_end = .;
 237         }
 238         __lowmem_len = ABSOLUTE(__lowmem_end) - ABSOLUTE(__lowmem_start);
 239         __lowmem_dwords = (__lowmem_len + 3) >> 2;
 240
 241         __high_clear_end = .;
 242
 243         __high_clear_len = ABSOLUTE(__high_clear_end) - ABSOLUTE(__high_clear_start);
 244         __high_clear_dwords = (__high_clear_len + 3) >> 2;
 245
 246         /* Start of the lowmem heap */
 247         . = ALIGN(16);
 248         __lowmem_heap = .;
 249
 250         /*
 251          * 32-bit code.  This is a hack for the moment due to the
 252          * real-mode segments also allocated.
 253          */
 254
 255         . = 0x100000;
 256
 257         __pm_code_start = .;
 258
 259         __text_vma = .;
 260         __text_lma = __pm_code_lma;
 261         .text : AT(__text_lma) {
 262                 FILL(0x90909090)
 263                 __text_start = .;
 264                 *(.text)
 265                 *(.text.*)
 266                 __text_end = .;
 267         }
 268
 269         . = ALIGN(16);
 270
 271         __rodata_vma = .;
 272         __rodata_lma = __rodata_vma + __text_lma - __text_vma;
 273         .rodata : AT(__rodata_lma) {
 274                 __rodata_start = .;
 275                 *(.rodata)
 276                 *(.rodata.*)
 277                 __rodata_end = .;
 278         }
 279
 280         . = ALIGN(4);
 281
 282         __ctors_vma = .;
 283         __ctors_lma = __ctors_vma + __text_lma - __text_vma;
 284         .ctors : AT(__ctors_lma) {
 285                 __ctors_start = .;
 286                 KEEP (*(SORT(.ctors.*)))
 287                 KEEP (*(.ctors))
 288                 __ctors_end = .;
 289         }
 290
 291         __dtors_vma = .;
 292         __dtors_lma = __dtors_vma + __text_lma - __text_vma;
 293         .dtors : AT(__dtors_lma) {
 294                 __dtors_start = .;
 295                 KEEP (*(SORT(.dtors.*)))
 296                 KEEP (*(.dtors))
 297                 __dtors_end = .;
 298         }
 299
 300         . = ALIGN(4);
 301
 302         __dynsym_vma = .;
 303         __dynsym_lma = __dynsym_vma + __text_lma - __text_vma;
 304         .dynsym : AT(__dynsym_lma) {
 305                 __dynsym_start = .;
 306                 *(.dynsym)
 307                 __dynsym_end = .;
 308         }
 309         __dynsym_len = __dynsym_end - __dynsym_start;
 310
 311         . = ALIGN(4);
 312
 313         __dynstr_vma = .;
 314         __dynstr_lma = __dynstr_vma + __text_lma - __text_vma;
 315         .dynstr : AT(__dynstr_lma) {
 316                 __dynstr_start = .;
 317                 *(.dynstr)
 318                 __dynstr_end = .;
 319         }
 320         __dynstr_len = __dynstr_end - __dynstr_start;
 321
 322         . = ALIGN(4);
 323
 324         __gnu_hash_vma = .;
 325         __gnu_hash_lma = __gnu_hash_vma + __text_lma - __text_vma;
 326         .gnu.hash : AT(__gnu_hash_lma) {
 327                 __gnu_hash_start = .;
 328                 *(.gnu.hash)
 329                 __gnu_hash_end = .;
 330         }
 331
 332
 333         . = ALIGN(4);
 334
 335         __dynlink_vma = .;
 336         __dynlink_lma = __dynlink_vma + __text_lma - __text_vma;
 337         .dynlink : AT(__dynlink_lma) {
 338                 __dynlink_start = .;
 339                 *(.dynlink)
 340                 __dynlink_end = .;
 341         }
 342
 343         . = ALIGN(4);
 344
 345         __got_vma = .;
 346         __got_lma = __got_vma + __text_lma - __text_vma;
 347         .got : AT(__got_lma) {
 348                 __got_start = .;
 349                 KEEP (*(.got.plt))
 350                 KEEP (*(.got))
 351                 __got_end = .;
 352         }
 353
 354         . = ALIGN(4);
 355
 356         __dynamic_vma = .;
 357         __dynamic_lma = __dynamic_vma + __text_lma - __text_vma;
 358         .dynamic : AT(__dynamic_lma) {
 359                 __dynamic_start = .;
 360                 *(.dynamic)
 361                 __dynamic_end = .;
 362         }
 363
 364         . = ALIGN(16);
 365
 366         __data_vma = .;
 367         __data_lma = __data_vma + __text_lma - __text_vma;
 368         .data : AT(__data_lma) {
 369                 __data_start = .;
 370                 *(.data)
 371                 *(.data.*)
 372                 __data_end = .;
 373         }
 374
 375         __pm_code_end = .;
 376         __pm_code_len = ABSOLUTE(__pm_code_end) - ABSOLUTE(__pm_code_start);
 377         __pm_code_dwords = (__pm_code_len + 3) >> 2;
 378
 379         . = ALIGN(128);
 380
 381         __bss_vma = .;
 382         __bss_lma = .;          /* Dummy */
 383         .bss (NOLOAD) : AT (__bss_lma) {
 384                 __bss_start = .;
 385                 *(.bss)
 386                 *(.bss.*)
 387                 *(COMMON)
 388                 __bss_end = .;
 389         }
 390         __bss_len = ABSOLUTE(__bss_end) - ABSOLUTE(__bss_start);
 391         __bss_dwords = (__bss_len + 3) >> 2;
 392
 393         /* Very large objects which don't need to be zeroed */
 394
 395         __hugebss_vma = .;
 396         __hugebss_lma = .;              /* Dummy */
 397         .hugebss (NOLOAD) : AT (__hugebss_lma) {
 398                 __hugebss_start = .;
 399                 *(.hugebss)
 400                 *(.hugebss.*)
 401                 __hugebss_end = .;
 402         }
 403         __hugebss_len = ABSOLUTE(__hugebss_end) - ABSOLUTE(__hugebss_start);
 404         __hugebss_dwords = (__hugebss_len + 3) >> 2;
 405
 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 }