1 /* 2 * Helper macros to support writing architecture specific 3 * linker scripts. 4 * 5 * A minimal linker scripts has following content: 6 * [This is a sample, architectures may have special requiriements] 7 * 8 * OUTPUT_FORMAT(...) 9 * OUTPUT_ARCH(...) 10 * ENTRY(...) 11 * SECTIONS 12 * { 13 * . = START; 14 * __init_begin = .; 15 * HEAD_TEXT_SECTION 16 * INIT_TEXT_SECTION(PAGE_SIZE) 17 * INIT_DATA_SECTION(...) 18 * PERCPU(PAGE_SIZE) 19 * __init_end = .; 20 * 21 * _stext = .; 22 * TEXT_SECTION = 0 23 * _etext = .; 24 * 25 * _sdata = .; 26 * RO_DATA_SECTION(PAGE_SIZE) 27 * RW_DATA_SECTION(...) 28 * _edata = .; 29 * 30 * EXCEPTION_TABLE(...) 31 * NOTES 32 * 33 * BSS_SECTION(0, 0, 0) 34 * _end = .; 35 * 36 * STABS_DEBUG 37 * DWARF_DEBUG 38 * 39 * DISCARDS // must be the last 40 * } 41 * 42 * [__init_begin, __init_end] is the init section that may be freed after init 43 * [_stext, _etext] is the text section 44 * [_sdata, _edata] is the data section 45 * 46 * Some of the included output section have their own set of constants. 47 * Examples are: [__initramfs_start, __initramfs_end] for initramfs and 48 * [__nosave_begin, __nosave_end] for the nosave data 49 */ 50 51 #ifndef LOAD_OFFSET 52 #define LOAD_OFFSET 0 53 #endif 54 55 #ifndef SYMBOL_PREFIX 56 #define VMLINUX_SYMBOL(sym) sym 57 #else 58 #define PASTE2(x,y) x##y 59 #define PASTE(x,y) PASTE2(x,y) 60 #define VMLINUX_SYMBOL(sym) PASTE(SYMBOL_PREFIX, sym) 61 #endif 62 63 /* Align . to a 8 byte boundary equals to maximum function alignment. */ 64 #define ALIGN_FUNCTION() . = ALIGN(8) 65 66 /* 67 * Align to a 32 byte boundary equal to the 68 * alignment gcc 4.5 uses for a struct 69 */ 70 #define STRUCT_ALIGNMENT 32 71 #define STRUCT_ALIGN() . = ALIGN(STRUCT_ALIGNMENT) 72 73 /* The actual configuration determine if the init/exit sections 74 * are handled as text/data or they can be discarded (which 75 * often happens at runtime) 76 */ 77 #ifdef CONFIG_HOTPLUG 78 #define DEV_KEEP(sec) *(.dev##sec) 79 #define DEV_DISCARD(sec) 80 #else 81 #define DEV_KEEP(sec) 82 #define DEV_DISCARD(sec) *(.dev##sec) 83 #endif 84 85 #ifdef CONFIG_HOTPLUG_CPU 86 #define CPU_KEEP(sec) *(.cpu##sec) 87 #define CPU_DISCARD(sec) 88 #else 89 #define CPU_KEEP(sec) 90 #define CPU_DISCARD(sec) *(.cpu##sec) 91 #endif 92 93 #if defined(CONFIG_MEMORY_HOTPLUG) 94 #define MEM_KEEP(sec) *(.mem##sec) 95 #define MEM_DISCARD(sec) 96 #else 97 #define MEM_KEEP(sec) 98 #define MEM_DISCARD(sec) *(.mem##sec) 99 #endif 100 101 #ifdef CONFIG_FTRACE_MCOUNT_RECORD 102 #define MCOUNT_REC() . = ALIGN(8); \ 103 VMLINUX_SYMBOL(__start_mcount_loc) = .; \ 104 *(__mcount_loc) \ 105 VMLINUX_SYMBOL(__stop_mcount_loc) = .; 106 #else 107 #define MCOUNT_REC() 108 #endif 109 110 #ifdef CONFIG_TRACE_BRANCH_PROFILING 111 #define LIKELY_PROFILE() VMLINUX_SYMBOL(__start_annotated_branch_profile) = .; \ 112 *(_ftrace_annotated_branch) \ 113 VMLINUX_SYMBOL(__stop_annotated_branch_profile) = .; 114 #else 115 #define LIKELY_PROFILE() 116 #endif 117 118 #ifdef CONFIG_PROFILE_ALL_BRANCHES 119 #define BRANCH_PROFILE() VMLINUX_SYMBOL(__start_branch_profile) = .; \ 120 *(_ftrace_branch) \ 121 VMLINUX_SYMBOL(__stop_branch_profile) = .; 122 #else 123 #define BRANCH_PROFILE() 124 #endif 125 126 #ifdef CONFIG_EVENT_TRACING 127 #define FTRACE_EVENTS() VMLINUX_SYMBOL(__start_ftrace_events) = .; \ 128 *(_ftrace_events) \ 129 VMLINUX_SYMBOL(__stop_ftrace_events) = .; 130 #else 131 #define FTRACE_EVENTS() 132 #endif 133 134 #ifdef CONFIG_TRACING 135 #define TRACE_PRINTKS() VMLINUX_SYMBOL(__start___trace_bprintk_fmt) = .; \ 136 *(__trace_printk_fmt) /* Trace_printk fmt' pointer */ \ 137 VMLINUX_SYMBOL(__stop___trace_bprintk_fmt) = .; 138 #else 139 #define TRACE_PRINTKS() 140 #endif 141 142 #ifdef CONFIG_FTRACE_SYSCALLS 143 #define TRACE_SYSCALLS() VMLINUX_SYMBOL(__start_syscalls_metadata) = .; \ 144 *(__syscalls_metadata) \ 145 VMLINUX_SYMBOL(__stop_syscalls_metadata) = .; 146 #else 147 #define TRACE_SYSCALLS() 148 #endif 149 150 151 #define KERNEL_DTB() \ 152 STRUCT_ALIGN(); \ 153 VMLINUX_SYMBOL(__dtb_start) = .; \ 154 *(.dtb.init.rodata) \ 155 VMLINUX_SYMBOL(__dtb_end) = .; 156 157 /* .data section */ 158 #define DATA_DATA \ 159 *(.data) \ 160 *(.ref.data) \ 161 *(.data..shared_aligned) /* percpu related */ \ 162 DEV_KEEP(init.data) \ 163 DEV_KEEP(exit.data) \ 164 CPU_KEEP(init.data) \ 165 CPU_KEEP(exit.data) \ 166 MEM_KEEP(init.data) \ 167 MEM_KEEP(exit.data) \ 168 . = ALIGN(32); \ 169 VMLINUX_SYMBOL(__start___tracepoints) = .; \ 170 *(__tracepoints) \ 171 VMLINUX_SYMBOL(__stop___tracepoints) = .; \ 172 /* implement dynamic printk debug */ \ 173 . = ALIGN(8); \ 174 VMLINUX_SYMBOL(__start___verbose) = .; \ 175 *(__verbose) \ 176 VMLINUX_SYMBOL(__stop___verbose) = .; \ 177 LIKELY_PROFILE() \ 178 BRANCH_PROFILE() \ 179 TRACE_PRINTKS() \ 180 \ 181 STRUCT_ALIGN(); \ 182 FTRACE_EVENTS() \ 183 \ 184 STRUCT_ALIGN(); \ 185 TRACE_SYSCALLS() 186 187 /* 188 * Data section helpers 189 */ 190 #define NOSAVE_DATA \ 191 . = ALIGN(PAGE_SIZE); \ 192 VMLINUX_SYMBOL(__nosave_begin) = .; \ 193 *(.data..nosave) \ 194 . = ALIGN(PAGE_SIZE); \ 195 VMLINUX_SYMBOL(__nosave_end) = .; 196 197 #define PAGE_ALIGNED_DATA(page_align) \ 198 . = ALIGN(page_align); \ 199 *(.data..page_aligned) 200 201 #define READ_MOSTLY_DATA(align) \ 202 . = ALIGN(align); \ 203 *(.data..read_mostly) \ 204 . = ALIGN(align); 205 206 #define CACHELINE_ALIGNED_DATA(align) \ 207 . = ALIGN(align); \ 208 *(.data..cacheline_aligned) 209 210 #define INIT_TASK_DATA(align) \ 211 . = ALIGN(align); \ 212 *(.data..init_task) 213 214 /* 215 * Read only Data 216 */ 217 #define RO_DATA_SECTION(align) \ 218 . = ALIGN((align)); \ 219 .rodata : AT(ADDR(.rodata) - LOAD_OFFSET) { \ 220 VMLINUX_SYMBOL(__start_rodata) = .; \ 221 *(.rodata) *(.rodata.*) \ 222 *(__vermagic) /* Kernel version magic */ \ 223 *(__markers_strings) /* Markers: strings */ \ 224 *(__tracepoints_strings)/* Tracepoints: strings */ \ 225 } \ 226 \ 227 .rodata1 : AT(ADDR(.rodata1) - LOAD_OFFSET) { \ 228 *(.rodata1) \ 229 } \ 230 \ 231 BUG_TABLE \ 232 \ 233 JUMP_TABLE \ 234 \ 235 /* PCI quirks */ \ 236 .pci_fixup : AT(ADDR(.pci_fixup) - LOAD_OFFSET) { \ 237 VMLINUX_SYMBOL(__start_pci_fixups_early) = .; \ 238 *(.pci_fixup_early) \ 239 VMLINUX_SYMBOL(__end_pci_fixups_early) = .; \ 240 VMLINUX_SYMBOL(__start_pci_fixups_header) = .; \ 241 *(.pci_fixup_header) \ 242 VMLINUX_SYMBOL(__end_pci_fixups_header) = .; \ 243 VMLINUX_SYMBOL(__start_pci_fixups_final) = .; \ 244 *(.pci_fixup_final) \ 245 VMLINUX_SYMBOL(__end_pci_fixups_final) = .; \ 246 VMLINUX_SYMBOL(__start_pci_fixups_enable) = .; \ 247 *(.pci_fixup_enable) \ 248 VMLINUX_SYMBOL(__end_pci_fixups_enable) = .; \ 249 VMLINUX_SYMBOL(__start_pci_fixups_resume) = .; \ 250 *(.pci_fixup_resume) \ 251 VMLINUX_SYMBOL(__end_pci_fixups_resume) = .; \ 252 VMLINUX_SYMBOL(__start_pci_fixups_resume_early) = .; \ 253 *(.pci_fixup_resume_early) \ 254 VMLINUX_SYMBOL(__end_pci_fixups_resume_early) = .; \ 255 VMLINUX_SYMBOL(__start_pci_fixups_suspend) = .; \ 256 *(.pci_fixup_suspend) \ 257 VMLINUX_SYMBOL(__end_pci_fixups_suspend) = .; \ 258 } \ 259 \ 260 /* Built-in firmware blobs */ \ 261 .builtin_fw : AT(ADDR(.builtin_fw) - LOAD_OFFSET) { \ 262 VMLINUX_SYMBOL(__start_builtin_fw) = .; \ 263 *(.builtin_fw) \ 264 VMLINUX_SYMBOL(__end_builtin_fw) = .; \ 265 } \ 266 \ 267 /* RapidIO route ops */ \ 268 .rio_ops : AT(ADDR(.rio_ops) - LOAD_OFFSET) { \ 269 VMLINUX_SYMBOL(__start_rio_switch_ops) = .; \ 270 *(.rio_switch_ops) \ 271 VMLINUX_SYMBOL(__end_rio_switch_ops) = .; \ 272 } \ 273 \ 274 TRACEDATA \ 275 \ 276 /* Kernel symbol table: Normal symbols */ \ 277 __ksymtab : AT(ADDR(__ksymtab) - LOAD_OFFSET) { \ 278 VMLINUX_SYMBOL(__start___ksymtab) = .; \ 279 *(__ksymtab) \ 280 VMLINUX_SYMBOL(__stop___ksymtab) = .; \ 281 } \ 282 \ 283 /* Kernel symbol table: GPL-only symbols */ \ 284 __ksymtab_gpl : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) { \ 285 VMLINUX_SYMBOL(__start___ksymtab_gpl) = .; \ 286 *(__ksymtab_gpl) \ 287 VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .; \ 288 } \ 289 \ 290 /* Kernel symbol table: Normal unused symbols */ \ 291 __ksymtab_unused : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) { \ 292 VMLINUX_SYMBOL(__start___ksymtab_unused) = .; \ 293 *(__ksymtab_unused) \ 294 VMLINUX_SYMBOL(__stop___ksymtab_unused) = .; \ 295 } \ 296 \ 297 /* Kernel symbol table: GPL-only unused symbols */ \ 298 __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \ 299 VMLINUX_SYMBOL(__start___ksymtab_unused_gpl) = .; \ 300 *(__ksymtab_unused_gpl) \ 301 VMLINUX_SYMBOL(__stop___ksymtab_unused_gpl) = .; \ 302 } \ 303 \ 304 /* Kernel symbol table: GPL-future-only symbols */ \ 305 __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \ 306 VMLINUX_SYMBOL(__start___ksymtab_gpl_future) = .; \ 307 *(__ksymtab_gpl_future) \ 308 VMLINUX_SYMBOL(__stop___ksymtab_gpl_future) = .; \ 309 } \ 310 \ 311 /* Kernel symbol table: Normal symbols */ \ 312 __kcrctab : AT(ADDR(__kcrctab) - LOAD_OFFSET) { \ 313 VMLINUX_SYMBOL(__start___kcrctab) = .; \ 314 *(__kcrctab) \ 315 VMLINUX_SYMBOL(__stop___kcrctab) = .; \ 316 } \ 317 \ 318 /* Kernel symbol table: GPL-only symbols */ \ 319 __kcrctab_gpl : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) { \ 320 VMLINUX_SYMBOL(__start___kcrctab_gpl) = .; \ 321 *(__kcrctab_gpl) \ 322 VMLINUX_SYMBOL(__stop___kcrctab_gpl) = .; \ 323 } \ 324 \ 325 /* Kernel symbol table: Normal unused symbols */ \ 326 __kcrctab_unused : AT(ADDR(__kcrctab_unused) - LOAD_OFFSET) { \ 327 VMLINUX_SYMBOL(__start___kcrctab_unused) = .; \ 328 *(__kcrctab_unused) \ 329 VMLINUX_SYMBOL(__stop___kcrctab_unused) = .; \ 330 } \ 331 \ 332 /* Kernel symbol table: GPL-only unused symbols */ \ 333 __kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \ 334 VMLINUX_SYMBOL(__start___kcrctab_unused_gpl) = .; \ 335 *(__kcrctab_unused_gpl) \ 336 VMLINUX_SYMBOL(__stop___kcrctab_unused_gpl) = .; \ 337 } \ 338 \ 339 /* Kernel symbol table: GPL-future-only symbols */ \ 340 __kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \ 341 VMLINUX_SYMBOL(__start___kcrctab_gpl_future) = .; \ 342 *(__kcrctab_gpl_future) \ 343 VMLINUX_SYMBOL(__stop___kcrctab_gpl_future) = .; \ 344 } \ 345 \ 346 /* Kernel symbol table: strings */ \ 347 __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) { \ 348 *(__ksymtab_strings) \ 349 } \ 350 \ 351 /* __*init sections */ \ 352 __init_rodata : AT(ADDR(__init_rodata) - LOAD_OFFSET) { \ 353 *(.ref.rodata) \ 354 DEV_KEEP(init.rodata) \ 355 DEV_KEEP(exit.rodata) \ 356 CPU_KEEP(init.rodata) \ 357 CPU_KEEP(exit.rodata) \ 358 MEM_KEEP(init.rodata) \ 359 MEM_KEEP(exit.rodata) \ 360 } \ 361 \ 362 /* Built-in module parameters. */ \ 363 __param : AT(ADDR(__param) - LOAD_OFFSET) { \ 364 VMLINUX_SYMBOL(__start___param) = .; \ 365 *(__param) \ 366 VMLINUX_SYMBOL(__stop___param) = .; \ 367 . = ALIGN((align)); \ 368 VMLINUX_SYMBOL(__end_rodata) = .; \ 369 } \ 370 . = ALIGN((align)); 371 372 /* RODATA & RO_DATA provided for backward compatibility. 373 * All archs are supposed to use RO_DATA() */ 374 #define RODATA RO_DATA_SECTION(4096) 375 #define RO_DATA(align) RO_DATA_SECTION(align) 376 377 #define SECURITY_INIT \ 378 .security_initcall.init : AT(ADDR(.security_initcall.init) - LOAD_OFFSET) { \ 379 VMLINUX_SYMBOL(__security_initcall_start) = .; \ 380 *(.security_initcall.init) \ 381 VMLINUX_SYMBOL(__security_initcall_end) = .; \ 382 } 383 384 /* .text section. Map to function alignment to avoid address changes 385 * during second ld run in second ld pass when generating System.map */ 386 #define TEXT_TEXT \ 387 ALIGN_FUNCTION(); \ 388 *(.text.hot) \ 389 *(.text) \ 390 *(.ref.text) \ 391 DEV_KEEP(init.text) \ 392 DEV_KEEP(exit.text) \ 393 CPU_KEEP(init.text) \ 394 CPU_KEEP(exit.text) \ 395 MEM_KEEP(init.text) \ 396 MEM_KEEP(exit.text) \ 397 *(.text.unlikely) 398 399 400 /* sched.text is aling to function alignment to secure we have same 401 * address even at second ld pass when generating System.map */ 402 #define SCHED_TEXT \ 403 ALIGN_FUNCTION(); \ 404 VMLINUX_SYMBOL(__sched_text_start) = .; \ 405 *(.sched.text) \ 406 VMLINUX_SYMBOL(__sched_text_end) = .; 407 408 /* spinlock.text is aling to function alignment to secure we have same 409 * address even at second ld pass when generating System.map */ 410 #define LOCK_TEXT \ 411 ALIGN_FUNCTION(); \ 412 VMLINUX_SYMBOL(__lock_text_start) = .; \ 413 *(.spinlock.text) \ 414 VMLINUX_SYMBOL(__lock_text_end) = .; 415 416 #define KPROBES_TEXT \ 417 ALIGN_FUNCTION(); \ 418 VMLINUX_SYMBOL(__kprobes_text_start) = .; \ 419 *(.kprobes.text) \ 420 VMLINUX_SYMBOL(__kprobes_text_end) = .; 421 422 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 423 #define IRQENTRY_TEXT \ 424 ALIGN_FUNCTION(); \ 425 VMLINUX_SYMBOL(__irqentry_text_start) = .; \ 426 *(.irqentry.text) \ 427 VMLINUX_SYMBOL(__irqentry_text_end) = .; 428 #else 429 #define IRQENTRY_TEXT 430 #endif 431 432 /* Section used for early init (in .S files) */ 433 #define HEAD_TEXT *(.head.text) 434 435 #define HEAD_TEXT_SECTION \ 436 .head.text : AT(ADDR(.head.text) - LOAD_OFFSET) { \ 437 HEAD_TEXT \ 438 } 439 440 /* 441 * Exception table 442 */ 443 #define EXCEPTION_TABLE(align) \ 444 . = ALIGN(align); \ 445 __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) { \ 446 VMLINUX_SYMBOL(__start___ex_table) = .; \ 447 *(__ex_table) \ 448 VMLINUX_SYMBOL(__stop___ex_table) = .; \ 449 } 450 451 /* 452 * Init task 453 */ 454 #define INIT_TASK_DATA_SECTION(align) \ 455 . = ALIGN(align); \ 456 .data..init_task : AT(ADDR(.data..init_task) - LOAD_OFFSET) { \ 457 INIT_TASK_DATA(align) \ 458 } 459 460 #ifdef CONFIG_CONSTRUCTORS 461 #define KERNEL_CTORS() . = ALIGN(8); \ 462 VMLINUX_SYMBOL(__ctors_start) = .; \ 463 *(.ctors) \ 464 VMLINUX_SYMBOL(__ctors_end) = .; 465 #else 466 #define KERNEL_CTORS() 467 #endif 468 469 /* init and exit section handling */ 470 #define INIT_DATA \ 471 *(.init.data) \ 472 DEV_DISCARD(init.data) \ 473 CPU_DISCARD(init.data) \ 474 MEM_DISCARD(init.data) \ 475 KERNEL_CTORS() \ 476 *(.init.rodata) \ 477 MCOUNT_REC() \ 478 DEV_DISCARD(init.rodata) \ 479 CPU_DISCARD(init.rodata) \ 480 MEM_DISCARD(init.rodata) \ 481 KERNEL_DTB() 482 483 #define INIT_TEXT \ 484 *(.init.text) \ 485 DEV_DISCARD(init.text) \ 486 CPU_DISCARD(init.text) \ 487 MEM_DISCARD(init.text) 488 489 #define EXIT_DATA \ 490 *(.exit.data) \ 491 DEV_DISCARD(exit.data) \ 492 DEV_DISCARD(exit.rodata) \ 493 CPU_DISCARD(exit.data) \ 494 CPU_DISCARD(exit.rodata) \ 495 MEM_DISCARD(exit.data) \ 496 MEM_DISCARD(exit.rodata) 497 498 #define EXIT_TEXT \ 499 *(.exit.text) \ 500 DEV_DISCARD(exit.text) \ 501 CPU_DISCARD(exit.text) \ 502 MEM_DISCARD(exit.text) 503 504 #define EXIT_CALL \ 505 *(.exitcall.exit) 506 507 /* 508 * bss (Block Started by Symbol) - uninitialized data 509 * zeroed during startup 510 */ 511 #define SBSS(sbss_align) \ 512 . = ALIGN(sbss_align); \ 513 .sbss : AT(ADDR(.sbss) - LOAD_OFFSET) { \ 514 *(.sbss) \ 515 *(.scommon) \ 516 } 517 518 #define BSS(bss_align) \ 519 . = ALIGN(bss_align); \ 520 .bss : AT(ADDR(.bss) - LOAD_OFFSET) { \ 521 *(.bss..page_aligned) \ 522 *(.dynbss) \ 523 *(.bss) \ 524 *(COMMON) \ 525 } 526 527 /* 528 * DWARF debug sections. 529 * Symbols in the DWARF debugging sections are relative to 530 * the beginning of the section so we begin them at 0. 531 */ 532 #define DWARF_DEBUG \ 533 /* DWARF 1 */ \ 534 .debug 0 : { *(.debug) } \ 535 .line 0 : { *(.line) } \ 536 /* GNU DWARF 1 extensions */ \ 537 .debug_srcinfo 0 : { *(.debug_srcinfo) } \ 538 .debug_sfnames 0 : { *(.debug_sfnames) } \ 539 /* DWARF 1.1 and DWARF 2 */ \ 540 .debug_aranges 0 : { *(.debug_aranges) } \ 541 .debug_pubnames 0 : { *(.debug_pubnames) } \ 542 /* DWARF 2 */ \ 543 .debug_info 0 : { *(.debug_info \ 544 .gnu.linkonce.wi.*) } \ 545 .debug_abbrev 0 : { *(.debug_abbrev) } \ 546 .debug_line 0 : { *(.debug_line) } \ 547 .debug_frame 0 : { *(.debug_frame) } \ 548 .debug_str 0 : { *(.debug_str) } \ 549 .debug_loc 0 : { *(.debug_loc) } \ 550 .debug_macinfo 0 : { *(.debug_macinfo) } \ 551 /* SGI/MIPS DWARF 2 extensions */ \ 552 .debug_weaknames 0 : { *(.debug_weaknames) } \ 553 .debug_funcnames 0 : { *(.debug_funcnames) } \ 554 .debug_typenames 0 : { *(.debug_typenames) } \ 555 .debug_varnames 0 : { *(.debug_varnames) } \ 556 557 /* Stabs debugging sections. */ 558 #define STABS_DEBUG \ 559 .stab 0 : { *(.stab) } \ 560 .stabstr 0 : { *(.stabstr) } \ 561 .stab.excl 0 : { *(.stab.excl) } \ 562 .stab.exclstr 0 : { *(.stab.exclstr) } \ 563 .stab.index 0 : { *(.stab.index) } \ 564 .stab.indexstr 0 : { *(.stab.indexstr) } \ 565 .comment 0 : { *(.comment) } 566 567 #ifdef CONFIG_GENERIC_BUG 568 #define BUG_TABLE \ 569 . = ALIGN(8); \ 570 __bug_table : AT(ADDR(__bug_table) - LOAD_OFFSET) { \ 571 VMLINUX_SYMBOL(__start___bug_table) = .; \ 572 *(__bug_table) \ 573 VMLINUX_SYMBOL(__stop___bug_table) = .; \ 574 } 575 #else 576 #define BUG_TABLE 577 #endif 578 579 #define JUMP_TABLE \ 580 . = ALIGN(8); \ 581 __jump_table : AT(ADDR(__jump_table) - LOAD_OFFSET) { \ 582 VMLINUX_SYMBOL(__start___jump_table) = .; \ 583 *(__jump_table) \ 584 VMLINUX_SYMBOL(__stop___jump_table) = .; \ 585 } 586 587 #ifdef CONFIG_PM_TRACE 588 #define TRACEDATA \ 589 . = ALIGN(4); \ 590 .tracedata : AT(ADDR(.tracedata) - LOAD_OFFSET) { \ 591 VMLINUX_SYMBOL(__tracedata_start) = .; \ 592 *(.tracedata) \ 593 VMLINUX_SYMBOL(__tracedata_end) = .; \ 594 } 595 #else 596 #define TRACEDATA 597 #endif 598 599 #define NOTES \ 600 .notes : AT(ADDR(.notes) - LOAD_OFFSET) { \ 601 VMLINUX_SYMBOL(__start_notes) = .; \ 602 *(.note.*) \ 603 VMLINUX_SYMBOL(__stop_notes) = .; \ 604 } 605 606 #define INIT_SETUP(initsetup_align) \ 607 . = ALIGN(initsetup_align); \ 608 VMLINUX_SYMBOL(__setup_start) = .; \ 609 *(.init.setup) \ 610 VMLINUX_SYMBOL(__setup_end) = .; 611 612 #define INITCALLS \ 613 *(.initcallearly.init) \ 614 VMLINUX_SYMBOL(__early_initcall_end) = .; \ 615 *(.initcall0.init) \ 616 *(.initcall0s.init) \ 617 *(.initcall1.init) \ 618 *(.initcall1s.init) \ 619 *(.initcall2.init) \ 620 *(.initcall2s.init) \ 621 *(.initcall3.init) \ 622 *(.initcall3s.init) \ 623 *(.initcall4.init) \ 624 *(.initcall4s.init) \ 625 *(.initcall5.init) \ 626 *(.initcall5s.init) \ 627 *(.initcallrootfs.init) \ 628 *(.initcall6.init) \ 629 *(.initcall6s.init) \ 630 *(.initcall7.init) \ 631 *(.initcall7s.init) 632 633 #define INIT_CALLS \ 634 VMLINUX_SYMBOL(__initcall_start) = .; \ 635 INITCALLS \ 636 VMLINUX_SYMBOL(__initcall_end) = .; 637 638 #define CON_INITCALL \ 639 VMLINUX_SYMBOL(__con_initcall_start) = .; \ 640 *(.con_initcall.init) \ 641 VMLINUX_SYMBOL(__con_initcall_end) = .; 642 643 #define SECURITY_INITCALL \ 644 VMLINUX_SYMBOL(__security_initcall_start) = .; \ 645 *(.security_initcall.init) \ 646 VMLINUX_SYMBOL(__security_initcall_end) = .; 647 648 #ifdef CONFIG_BLK_DEV_INITRD 649 #define INIT_RAM_FS \ 650 . = ALIGN(4); \ 651 VMLINUX_SYMBOL(__initramfs_start) = .; \ 652 *(.init.ramfs) \ 653 . = ALIGN(8); \ 654 *(.init.ramfs.info) 655 #else 656 #define INIT_RAM_FS 657 #endif 658 659 /* 660 * Default discarded sections. 661 * 662 * Some archs want to discard exit text/data at runtime rather than 663 * link time due to cross-section references such as alt instructions, 664 * bug table, eh_frame, etc. DISCARDS must be the last of output 665 * section definitions so that such archs put those in earlier section 666 * definitions. 667 */ 668 #define DISCARDS \ 669 /DISCARD/ : { \ 670 EXIT_TEXT \ 671 EXIT_DATA \ 672 EXIT_CALL \ 673 *(.discard) \ 674 *(.discard.*) \ 675 } 676 677 /** 678 * PERCPU_VADDR - define output section for percpu area 679 * @vaddr: explicit base address (optional) 680 * @phdr: destination PHDR (optional) 681 * 682 * Macro which expands to output section for percpu area. If @vaddr 683 * is not blank, it specifies explicit base address and all percpu 684 * symbols will be offset from the given address. If blank, @vaddr 685 * always equals @laddr + LOAD_OFFSET. 686 * 687 * @phdr defines the output PHDR to use if not blank. Be warned that 688 * output PHDR is sticky. If @phdr is specified, the next output 689 * section in the linker script will go there too. @phdr should have 690 * a leading colon. 691 * 692 * Note that this macros defines __per_cpu_load as an absolute symbol. 693 * If there is no need to put the percpu section at a predetermined 694 * address, use PERCPU(). 695 */ 696 #define PERCPU_VADDR(vaddr, phdr) \ 697 VMLINUX_SYMBOL(__per_cpu_load) = .; \ 698 .data..percpu vaddr : AT(VMLINUX_SYMBOL(__per_cpu_load) \ 699 - LOAD_OFFSET) { \ 700 VMLINUX_SYMBOL(__per_cpu_start) = .; \ 701 *(.data..percpu..first) \ 702 . = ALIGN(PAGE_SIZE); \ 703 *(.data..percpu..page_aligned) \ 704 *(.data..percpu..readmostly) \ 705 *(.data..percpu) \ 706 *(.data..percpu..shared_aligned) \ 707 VMLINUX_SYMBOL(__per_cpu_end) = .; \ 708 } phdr \ 709 . = VMLINUX_SYMBOL(__per_cpu_load) + SIZEOF(.data..percpu); 710 711 /** 712 * PERCPU - define output section for percpu area, simple version 713 * @align: required alignment 714 * 715 * Align to @align and outputs output section for percpu area. This 716 * macro doesn't maniuplate @vaddr or @phdr and __per_cpu_load and 717 * __per_cpu_start will be identical. 718 * 719 * This macro is equivalent to ALIGN(align); PERCPU_VADDR( , ) except 720 * that __per_cpu_load is defined as a relative symbol against 721 * .data..percpu which is required for relocatable x86_32 722 * configuration. 723 */ 724 #define PERCPU(align) \ 725 . = ALIGN(align); \ 726 .data..percpu : AT(ADDR(.data..percpu) - LOAD_OFFSET) { \ 727 VMLINUX_SYMBOL(__per_cpu_load) = .; \ 728 VMLINUX_SYMBOL(__per_cpu_start) = .; \ 729 *(.data..percpu..first) \ 730 . = ALIGN(PAGE_SIZE); \ 731 *(.data..percpu..page_aligned) \ 732 *(.data..percpu..readmostly) \ 733 *(.data..percpu) \ 734 *(.data..percpu..shared_aligned) \ 735 VMLINUX_SYMBOL(__per_cpu_end) = .; \ 736 } 737 738 739 /* 740 * Definition of the high level *_SECTION macros 741 * They will fit only a subset of the architectures 742 */ 743 744 745 /* 746 * Writeable data. 747 * All sections are combined in a single .data section. 748 * The sections following CONSTRUCTORS are arranged so their 749 * typical alignment matches. 750 * A cacheline is typical/always less than a PAGE_SIZE so 751 * the sections that has this restriction (or similar) 752 * is located before the ones requiring PAGE_SIZE alignment. 753 * NOSAVE_DATA starts and ends with a PAGE_SIZE alignment which 754 * matches the requirment of PAGE_ALIGNED_DATA. 755 * 756 * use 0 as page_align if page_aligned data is not used */ 757 #define RW_DATA_SECTION(cacheline, pagealigned, inittask) \ 758 . = ALIGN(PAGE_SIZE); \ 759 .data : AT(ADDR(.data) - LOAD_OFFSET) { \ 760 INIT_TASK_DATA(inittask) \ 761 NOSAVE_DATA \ 762 PAGE_ALIGNED_DATA(pagealigned) \ 763 CACHELINE_ALIGNED_DATA(cacheline) \ 764 READ_MOSTLY_DATA(cacheline) \ 765 DATA_DATA \ 766 CONSTRUCTORS \ 767 } 768 769 #define INIT_TEXT_SECTION(inittext_align) \ 770 . = ALIGN(inittext_align); \ 771 .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) { \ 772 VMLINUX_SYMBOL(_sinittext) = .; \ 773 INIT_TEXT \ 774 VMLINUX_SYMBOL(_einittext) = .; \ 775 } 776 777 #define INIT_DATA_SECTION(initsetup_align) \ 778 .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) { \ 779 INIT_DATA \ 780 INIT_SETUP(initsetup_align) \ 781 INIT_CALLS \ 782 CON_INITCALL \ 783 SECURITY_INITCALL \ 784 INIT_RAM_FS \ 785 } 786 787 #define BSS_SECTION(sbss_align, bss_align, stop_align) \ 788 . = ALIGN(sbss_align); \ 789 VMLINUX_SYMBOL(__bss_start) = .; \ 790 SBSS(sbss_align) \ 791 BSS(bss_align) \ 792 . = ALIGN(stop_align); \ 793 VMLINUX_SYMBOL(__bss_stop) = .; 794