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 * 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 } 429
