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