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         HIDDEN(__module_start = .);
  30         .prefix : {
  31                 *(.prefix)
  32         }
  33
  34         /* "Early" sections (before the load) */
  35         . = 0x1000;
  36
  37         .earlybss (NOLOAD) : {
  38                 HIDDEN(__earlybss_start = .);
  39                 *(.earlybss)
  40                 HIDDEN(__earlybss_end = .);
  41         }
  42         HIDDEN(__earlybss_len = ABSOLUTE(__earlybss_end) - ABSOLUTE(__earlybss_start));
  43         HIDDEN(__earlybss_dwords = (__earlybss_len + 3) >> 2);
  44
  45         . = ALIGN(4);
  46         .bss16 (NOLOAD) : {
  47                 HIDDEN(__bss16_start = .);
  48                 *(.bss16)
  49                 HIDDEN(__bss16_end = .);
  50         }
  51         HIDDEN(__bss16_len = ABSOLUTE(__bss16_end) - ABSOLUTE(__bss16_start));
  52         HIDDEN(__bss16_dwords = (__bss16_len + 3) >> 2);
  53
  54         . = ALIGN(4);
  55         .config : AT (__config_lma) {
  56                 HIDDEN(__config_start = .);
  57                 *(.config)
  58                 HIDDEN(__config_end = .);
  59         }
  60         HIDDEN(__config_len = ABSOLUTE(__config_end) - ABSOLUTE(__config_start));
  61         HIDDEN(__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                 HIDDEN(__replacestub_start = .);
  68                 *(.replacestub)
  69                 HIDDEN(__replacestub_end = .);
  70         }
  71         HIDDEN(__replacestub_len = ABSOLUTE(__replacestub_end) - ABSOLUTE(__replacestub_start));
  72         HIDDEN(__replacestub_dwords = (__replacestub_len + 3) >> 2);
  73
  74         . = ALIGN(16);
  75         HIDDEN(__gentextnr_lma = .);
  76         .gentextnr : AT(__gentextnr_lma) {
  77                 HIDDEN(__gentextnr_start = .);
  78                 *(.gentextnr)
  79                 HIDDEN(__gentextnr_end = .);
  80         }
  81         HIDDEN(__gentextnr_len = ABSOLUTE(__gentextnr_end) - ABSOLUTE(__gentextnr_start));
  82         HIDDEN(__gentextnr_dwords = (__gentextnr_len + 3) >> 2);
  83
  84         . = STACK_BASE;
  85         .stack16 : AT(STACK_BASE) {
  86                 HIDDEN(__stack16_start = .);
  87                 . += STACK_LEN;
  88                 HIDDEN(__stack16_end = .);
  89         }
  90         HIDDEN(__stack16_len = ABSOLUTE(__stack16_end) - ABSOLUTE(__stack16_start));
  91         HIDDEN(__stack16_dwords = (__stack16_len + 3) >> 2);
  92
  93         /* Initialized sections */
  94
  95         . = 0x7c00;
  96         .init : {
  97                 FILL(0x90909090)
  98                 HIDDEN(__init_start = .);
  99                 *(.init)
 100                 HIDDEN(__init_end = .);
 101         }
 102         HIDDEN(__init_len = ABSOLUTE(__init_end) - ABSOLUTE(__init_start));
 103         HIDDEN(__init_dwords = (__init_len + 3) >> 2);
 104
 105         .text16 : {
 106                 FILL(0x90909090)
 107                 HIDDEN(__text16_start = .);
 108                 *(.text16)
 109                 HIDDEN(__text16_end = .);
 110         }
 111         HIDDEN(__text16_len = ABSOLUTE(__text16_end) - ABSOLUTE(__text16_start));
 112         HIDDEN(__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                 HIDDEN(__textnr_start = .);
 122                 *(.textnr)
 123                 HIDDEN(__textnr_end = .);
 124         }
 125         HIDDEN(__textnr_len = ABSOLUTE(__textnr_end) - ABSOLUTE(__textnr_start));
 126         HIDDEN(__textnr_dwords = (__textnr_len + 3) >> 2);
 127
 128         . = ALIGN(16);
 129         HIDDEN(__bcopyxx_start = .);
 130
 131         .bcopyxx.text : {
 132                 FILL(0x90909090)
 133                 HIDDEN(__bcopyxx_text_start = .);
 134                 *(.bcopyxx.text)
 135                 HIDDEN(__bcopyxx_text_end = .);
 136         }
 137         HIDDEN(__bcopyxx_text_len = ABSOLUTE(__bcopyxx_text_end) - ABSOLUTE(__bcopyxx_text_start));
 138         HIDDEN(__bcopyxx_text_dwords = (__bcopyxx_text_len + 3) >> 2);
 139
 140         .bcopyxx.data : {
 141                 HIDDEN(__bcopyxx_data_start = .);
 142                 *(.bcopyxx.text)
 143                 HIDDEN(__bcopyxx_data_end = .);
 144         }
 145         HIDDEN(__bcopyxx_data_len = ABSOLUTE(__bcopyxx_data_end) - ABSOLUTE(__bcopyxx_data_start));
 146         HIDDEN(__bcopyxx_data_dwords = (__bcopyxx_data_len + 3) >> 2);
 147
 148         HIDDEN(__bcopyxx_end = .);
 149         HIDDEN(__bcopyxx_len = ABSOLUTE(__bcopyxx_end) - ABSOLUTE(__bcopyxx_start));
 150         HIDDEN(__bcopyxx_dwords = (__bcopyxx_len + 3) >> 2);
 151
 152         . = ALIGN(4);
 153         .data16 : {
 154                 HIDDEN(__data16_start = .);
 155                 *(.data16)
 156                 HIDDEN(__data16_end = .);
 157         }
 158         HIDDEN(__data16_len = ABSOLUTE(__data16_end) - ABSOLUTE(__data16_start));
 159         HIDDEN(__data16_dwords = (__data16_len + 3) >> 2);
 160
 161         . = ALIGN(4);
 162         HIDDEN(__config_lma = .);
 163         . += SIZEOF(.config);
 164
 165         . = ALIGN(4);
 166         HIDDEN(__replacestub_lma = .);
 167         . += SIZEOF(.replacestub);
 168
 169         /* The 32-bit code loads above the non-progbits sections */
 170
 171         . = ALIGN(16);
 172         HIDDEN(__pm_code_lma = .);
 173
 174         HIDDEN(__high_clear_start = .);
 175
 176         . = ALIGN(512);
 177         .adv (NOLOAD) : {
 178                 HIDDEN(__adv_start = .);
 179                 *(.adv)
 180                 HIDDEN(__adv_end = .);
 181         }
 182         HIDDEN(__adv_len = ABSOLUTE(__adv_end) - ABSOLUTE(__adv_start));
 183         HIDDEN(__adv_dwords = (__adv_len + 3) >> 2);
 184
 185         /* Late uninitialized sections */
 186
 187         . = ALIGN(4);
 188         .uibss (NOLOAD) : {
 189                 HIDDEN(__uibss_start = .);
 190                 *(.uibss)
 191                 HIDDEN(__uibss_end = .);
 192         }
 193         HIDDEN(__uibss_len = ABSOLUTE(__uibss_end) - ABSOLUTE(__uibss_start));
 194         HIDDEN(__uibss_dwords = (__uibss_len + 3) >> 2);
 195
 196         HIDDEN(_end16 = .);
 197         HIDDEN(__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         HIDDEN(real_mode_seg = core_real_mode >> 4);
 208
 209         . = ALIGN(65536);
 210         .xfer_buf (NOLOAD) : {
 211                 *(.xfer_buf)
 212         }
 213         HIDDEN(xfer_buf_seg = core_xfer_buf >> 4);
 214
 215         /*
 216          * Used to allocate lowmem buffers from 32-bit code
 217          */
 218         .lowmem (NOLOAD) : {
 219                 HIDDEN(__lowmem_start = .);
 220                 *(.lowmem)
 221                 HIDDEN(__lowmem_end = .);
 222         }
 223         HIDDEN(__lowmem_len = ABSOLUTE(__lowmem_end) - ABSOLUTE(__lowmem_start));
 224         HIDDEN(__lowmem_dwords = (__lowmem_len + 3) >> 2);
 225
 226         HIDDEN(__high_clear_end = .);
 227
 228         HIDDEN(__high_clear_len = ABSOLUTE(__high_clear_end) - ABSOLUTE(__high_clear_start));
 229         HIDDEN(__high_clear_dwords = (__high_clear_len + 3) >> 2);
 230
 231         /* Start of the lowmem heap */
 232         . = ALIGN(16);
 233         HIDDEN(__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         HIDDEN(__pm_code_start = .);
 243
 244         HIDDEN(__text_vma = .);
 245         HIDDEN(__text_lma = __pm_code_lma);
 246         .text : AT(__text_lma) {
 247                 FILL(0x90909090)
 248                 HIDDEN(__text_start = .);
 249                 *(.text)
 250                 *(.text.*)
 251                 HIDDEN(__text_end = .);
 252         }
 253
 254         . = ALIGN(16);
 255
 256         HIDDEN(__rodata_vma = .);
 257         HIDDEN(__rodata_lma = __rodata_vma + __text_lma - __text_vma);
 258         .rodata : AT(__rodata_lma) {
 259                 HIDDEN(__rodata_start = .);
 260                 *(.rodata)
 261                 *(.rodata.*)
 262                 HIDDEN(__rodata_end = .);
 263         }
 264
 265         . = ALIGN(4);
 266
 267         HIDDEN(__ctors_vma = .);
 268         HIDDEN(__ctors_lma = __ctors_vma + __text_lma - __text_vma);
 269         .ctors : AT(__ctors_lma) {
 270                 HIDDEN(__ctors_start = .);
 271                 KEEP (*(SORT(.preinit_array*)))
 272                 KEEP (*(SORT(.init_array*)))
 273                 KEEP (*(SORT(.ctors*)))
 274                 HIDDEN(__ctors_end = .);
 275         }
 276
 277         HIDDEN(__dtors_vma = .);
 278         HIDDEN(__dtors_lma = __dtors_vma + __text_lma - __text_vma);
 279         .dtors : AT(__dtors_lma) {
 280                 HIDDEN(__dtors_start = .);
 281                 KEEP (*(SORT(.fini_array*)))
 282                 KEEP (*(SORT(.dtors*)))
 283                 HIDDEN(__dtors_end = .);
 284         }
 285
 286         . = ALIGN(4);
 287
 288         HIDDEN(__dynsym_vma = .);
 289         HIDDEN(__dynsym_lma = __dynsym_vma + __text_lma - __text_vma);
 290         .dynsym : AT(__dynsym_lma) {
 291                 HIDDEN(__dynsym_start = .);
 292                 *(.dynsym)
 293                 HIDDEN(__dynsym_end = .);
 294         }
 295         HIDDEN(__dynsym_len = __dynsym_end - __dynsym_start);
 296
 297         . = ALIGN(4);
 298
 299         HIDDEN(__dynstr_vma = .);
 300         HIDDEN(__dynstr_lma = __dynstr_vma + __text_lma - __text_vma);
 301         .dynstr : AT(__dynstr_lma) {
 302                 HIDDEN(__dynstr_start = .);
 303                 *(.dynstr)
 304                 HIDDEN(__dynstr_end = .);
 305         }
 306         HIDDEN(__dynstr_len = __dynstr_end - __dynstr_start);
 307
 308         . = ALIGN(4);
 309
 310         HIDDEN(__gnu_hash_vma = .);
 311         HIDDEN(__gnu_hash_lma = __gnu_hash_vma + __text_lma - __text_vma);
 312         .gnu.hash : AT(__gnu_hash_lma) {
 313                 HIDDEN(__gnu_hash_start = .);
 314                 *(.gnu.hash)
 315                 HIDDEN(__gnu_hash_end = .);
 316         }
 317
 318
 319         . = ALIGN(4);
 320
 321         HIDDEN(__dynlink_vma = .);
 322         HIDDEN(__dynlink_lma = __dynlink_vma + __text_lma - __text_vma);
 323         .dynlink : AT(__dynlink_lma) {
 324                 HIDDEN(__dynlink_start = .);
 325                 *(.dynlink)
 326                 HIDDEN(__dynlink_end = .);
 327         }
 328
 329         . = ALIGN(4);
 330
 331         HIDDEN(__got_vma = .);
 332         HIDDEN(__got_lma = __got_vma + __text_lma - __text_vma);
 333         .got : AT(__got_lma) {
 334                 HIDDEN(__got_start = .);
 335                 KEEP (*(.got.plt))
 336                 KEEP (*(.got))
 337                 HIDDEN(__got_end = .);
 338         }
 339
 340         . = ALIGN(4);
 341
 342         HIDDEN(__dynamic_vma = .);
 343         HIDDEN(__dynamic_lma = __dynamic_vma + __text_lma - __text_vma);
 344         .dynamic : AT(__dynamic_lma) {
 345                 HIDDEN(__dynamic_start = .);
 346                 *(.dynamic)
 347                 HIDDEN(__dynamic_end = .);
 348         }
 349
 350         . = ALIGN(16);
 351
 352         HIDDEN(__data_vma = .);
 353         HIDDEN(__data_lma = __data_vma + __text_lma - __text_vma);
 354         .data : AT(__data_lma) {
 355                 HIDDEN(__data_start = .);
 356                 *(.data)
 357                 *(.data.*)
 358                 HIDDEN(__data_end = .);
 359         }
 360
 361         HIDDEN(__pm_code_end = .);
 362         HIDDEN(__pm_code_len = ABSOLUTE(__pm_code_end) - ABSOLUTE(__pm_code_start));
 363         HIDDEN(__pm_code_dwords = (__pm_code_len + 3) >> 2);
 364
 365         . = ALIGN(128);
 366
 367         HIDDEN(__bss_vma = .);
 368         HIDDEN(__bss_lma = .);          /* Dummy */
 369         .bss (NOLOAD) : AT (__bss_lma) {
 370                 HIDDEN(__bss_start = .);
 371                 *(.bss)
 372                 *(.bss.*)
 373                 *(COMMON)
 374                 HIDDEN(__bss_end = .);
 375         }
 376         HIDDEN(__bss_len = ABSOLUTE(__bss_end) - ABSOLUTE(__bss_start));
 377         HIDDEN(__bss_dwords = (__bss_len + 3) >> 2);
 378
 379         /* Data saved away before bss initialization */
 380         . = ALIGN(128);
 381
 382         HIDDEN(__savedata_vma = .);
 383         HIDDEN(__savedata_lma = .);             /* Dummy */
 384         .savedata (NOLOAD) : AT (__savedata_lma) {
 385                 HIDDEN(__savedata_start = .);
 386                 *(.savedata)
 387                 *(.savedata.*)
 388                 HIDDEN(__savedata_end = .);
 389         }
 390         HIDDEN(__savedata_len = ABSOLUTE(__savedata_end) - ABSOLUTE(__savedata_start));
 391         HIDDEN(__savedata_dwords = (__savedata_len + 3) >> 2);
 392
 393         /* XXX: This stack should be unified with the COM32 stack */
 394         HIDDEN(__stack_vma = .);
 395         __stack_lma = .;        /* Dummy */
 396         .stack (NOLOAD) : AT(__stack_lma) {
 397                 HIDDEN(__stack_start = .);
 398                 *(.stack)
 399                 HIDDEN(__stack_end = .);
 400         }
 401         HIDDEN(__stack_len = ABSOLUTE(__stack_end) - ABSOLUTE(__stack_start));
 402         HIDDEN(__stack_dwords = (__stack_len + 3) >> 2);
 403
 404         HIDDEN(_end = .);
 405
 406         /* Heap follows after our own PM code */
 407         . = ALIGN(65536);
 408         HIDDEN(free_high_memory = .);
 409
 410         /* Stuff we don't need... */
 411         /DISCARD/ : {
 412                 *(.eh_frame)
 413         }
 414 }