| | 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_SECTION(CACHELINE_SIZE) |
| | 19 | * __init_end = .; |
| | 20 | * |
| | 21 | * _stext = .; |
| | 22 | * TEXT_SECTION = 0 |
| | 23 | * _etext = .; |
| | 24 | * |
| | 25 | * _sdata = .; |
| | 26 | * RO_DATA(PAGE_SIZE) |
| | 27 | * RW_DATA(...) |
| | 28 | * _edata = .; |
| | 29 | * |
| | 30 | * EXCEPTION_TABLE(...) |
| | 31 | * |
| | 32 | * BSS_SECTION(0, 0, 0) |
| | 33 | * _end = .; |
| | 34 | * |
| | 35 | * STABS_DEBUG |
| | 36 | * DWARF_DEBUG |
| | 37 | * |
| | 38 | * DISCARDS // must be the last |
| | 39 | * } |
| | 40 | * |
| | 41 | * [__init_begin, __init_end] is the init section that may be freed after init |
| | 42 | * // __init_begin and __init_end should be page aligned, so that we can |
| | 43 | * // free the whole .init memory |
| | 44 | * [_stext, _etext] is the text section |
| | 45 | * [_sdata, _edata] is the data section |
| | 46 | * |
| | 47 | * Some of the included output section have their own set of constants. |
| | 48 | * Examples are: [__initramfs_start, __initramfs_end] for initramfs and |
| | 49 | * [__nosave_begin, __nosave_end] for the nosave data |
| | 50 | */ |
| | 51 | |
| | 52 | #ifndef LOAD_OFFSET |
| | 53 | #define LOAD_OFFSET 0 |
| | 54 | #endif |
| | 55 | |
| | 56 | /* |
| | 57 | * Only some architectures want to have the .notes segment visible in |
| | 58 | * a separate PT_NOTE ELF Program Header. When this happens, it needs |
| | 59 | * to be visible in both the kernel text's PT_LOAD and the PT_NOTE |
| | 60 | * Program Headers. In this case, though, the PT_LOAD needs to be made |
| | 61 | * the default again so that all the following sections don't also end |
| | 62 | * up in the PT_NOTE Program Header. |
| | 63 | */ |
| | 64 | #ifdef EMITS_PT_NOTE |
| | 65 | #define NOTES_HEADERS :text :note |
| | 66 | #define NOTES_HEADERS_RESTORE __restore_ph : { *(.__restore_ph) } :text |
| | 67 | #else |
| | 68 | #define NOTES_HEADERS |
| | 69 | #define NOTES_HEADERS_RESTORE |
| | 70 | #endif |
| | 71 | |
| | 72 | /* |
| | 73 | * Some architectures have non-executable read-only exception tables. |
| | 74 | * They can be added to the RO_DATA segment by specifying their desired |
| | 75 | * alignment. |
| | 76 | */ |
| | 77 | #ifdef RO_EXCEPTION_TABLE_ALIGN |
| | 78 | #define RO_EXCEPTION_TABLE EXCEPTION_TABLE(RO_EXCEPTION_TABLE_ALIGN) |
| | 79 | #else |
| | 80 | #define RO_EXCEPTION_TABLE |
| | 81 | #endif |
| | 82 | |
| | 83 | /* Align . to a 8 byte boundary equals to maximum function alignment. */ |
| | 84 | #define ALIGN_FUNCTION() . = ALIGN(8) |
| | 85 | |
| | 86 | /* |
| | 87 | * LD_DEAD_CODE_DATA_ELIMINATION option enables -fdata-sections, which |
| | 88 | * generates .data.identifier sections, which need to be pulled in with |
| | 89 | * .data. We don't want to pull in .data..other sections, which Linux |
| | 90 | * has defined. Same for text and bss. |
| | 91 | * |
| | 92 | * RODATA_MAIN is not used because existing code already defines .rodata.x |
| | 93 | * sections to be brought in with rodata. |
| | 94 | */ |
| | 95 | #ifdef CONFIG_LD_DEAD_CODE_DATA_ELIMINATION |
| | 96 | #define TEXT_MAIN .text .text.[0-9a-zA-Z_]* |
| | 97 | #define DATA_MAIN .data .data.[0-9a-zA-Z_]* .data..LPBX* |
| | 98 | #define SDATA_MAIN .sdata .sdata.[0-9a-zA-Z_]* |
| | 99 | #define RODATA_MAIN .rodata .rodata.[0-9a-zA-Z_]* |
| | 100 | #define BSS_MAIN .bss .bss.[0-9a-zA-Z_]* |
| | 101 | #define SBSS_MAIN .sbss .sbss.[0-9a-zA-Z_]* |
| | 102 | #else |
| | 103 | #define TEXT_MAIN .text |
| | 104 | #define DATA_MAIN .data |
| | 105 | #define SDATA_MAIN .sdata |
| | 106 | #define RODATA_MAIN .rodata |
| | 107 | #define BSS_MAIN .bss |
| | 108 | #define SBSS_MAIN .sbss |
| | 109 | #endif |
| | 110 | |
| | 111 | /* |
| | 112 | * GCC 4.5 and later have a 32 bytes section alignment for structures. |
| | 113 | * Except GCC 4.9, that feels the need to align on 64 bytes. |
| | 114 | */ |
| | 115 | #if __GNUC__ == 4 && __GNUC_MINOR__ == 9 |
| | 116 | #define STRUCT_ALIGNMENT 64 |
| | 117 | #else |
| | 118 | #define STRUCT_ALIGNMENT 32 |
| | 119 | #endif |
| | 120 | #define STRUCT_ALIGN() . = ALIGN(STRUCT_ALIGNMENT) |
| | 121 | |
| | 122 | /* |
| | 123 | * The order of the sched class addresses are important, as they are |
| | 124 | * used to determine the order of the priority of each sched class in |
| | 125 | * relation to each other. |
| | 126 | */ |
| | 127 | #define SCHED_DATA \ |
| | 128 | STRUCT_ALIGN(); \ |
| | 129 | __begin_sched_classes = .; \ |
| | 130 | *(__idle_sched_class) \ |
| | 131 | *(__fair_sched_class) \ |
| | 132 | *(__rt_sched_class) \ |
| | 133 | *(__dl_sched_class) \ |
| | 134 | *(__stop_sched_class) \ |
| | 135 | __end_sched_classes = .; |
| | 136 | |
| | 137 | /* The actual configuration determine if the init/exit sections |
| | 138 | * are handled as text/data or they can be discarded (which |
| | 139 | * often happens at runtime) |
| | 140 | */ |
| | 141 | #ifdef CONFIG_HOTPLUG_CPU |
| | 142 | #define CPU_KEEP(sec) *(.cpu##sec) |
| | 143 | #define CPU_DISCARD(sec) |
| | 144 | #else |
| | 145 | #define CPU_KEEP(sec) |
| | 146 | #define CPU_DISCARD(sec) *(.cpu##sec) |
| | 147 | #endif |
| | 148 | |
| | 149 | #if defined(CONFIG_MEMORY_HOTPLUG) |
| | 150 | #define MEM_KEEP(sec) *(.mem##sec) |
| | 151 | #define MEM_DISCARD(sec) |
| | 152 | #else |
| | 153 | #define MEM_KEEP(sec) |
| | 154 | #define MEM_DISCARD(sec) *(.mem##sec) |
| | 155 | #endif |
| | 156 | |
| | 157 | #ifdef CONFIG_FTRACE_MCOUNT_RECORD |
| | 158 | /* |
| | 159 | * The ftrace call sites are logged to a section whose name depends on the |
| | 160 | * compiler option used. A given kernel image will only use one, AKA |
| | 161 | * FTRACE_CALLSITE_SECTION. We capture all of them here to avoid header |
| | 162 | * dependencies for FTRACE_CALLSITE_SECTION's definition. |
| | 163 | * |
| | 164 | * Need to also make ftrace_stub_graph point to ftrace_stub |
| | 165 | * so that the same stub location may have different protocols |
| | 166 | * and not mess up with C verifiers. |
| | 167 | */ |
| | 168 | #define MCOUNT_REC() . = ALIGN(8); \ |
| | 169 | __start_mcount_loc = .; \ |
| | 170 | KEEP(*(__mcount_loc)) \ |
| | 171 | KEEP(*(__patchable_function_entries)) \ |
| | 172 | __stop_mcount_loc = .; \ |
| | 173 | ftrace_stub_graph = ftrace_stub; |
| | 174 | #else |
| | 175 | # ifdef CONFIG_FUNCTION_TRACER |
| | 176 | # define MCOUNT_REC() ftrace_stub_graph = ftrace_stub; |
| | 177 | # else |
| | 178 | # define MCOUNT_REC() |
| | 179 | # endif |
| | 180 | #endif |
| | 181 | |
| | 182 | #ifdef CONFIG_TRACE_BRANCH_PROFILING |
| | 183 | #define LIKELY_PROFILE() __start_annotated_branch_profile = .; \ |
| | 184 | KEEP(*(_ftrace_annotated_branch)) \ |
| | 185 | __stop_annotated_branch_profile = .; |
| | 186 | #else |
| | 187 | #define LIKELY_PROFILE() |
| | 188 | #endif |
| | 189 | |
| | 190 | #ifdef CONFIG_PROFILE_ALL_BRANCHES |
| | 191 | #define BRANCH_PROFILE() __start_branch_profile = .; \ |
| | 192 | KEEP(*(_ftrace_branch)) \ |
| | 193 | __stop_branch_profile = .; |
| | 194 | #else |
| | 195 | #define BRANCH_PROFILE() |
| | 196 | #endif |
| | 197 | |
| | 198 | #ifdef CONFIG_KPROBES |
| | 199 | #define KPROBE_BLACKLIST() . = ALIGN(8); \ |
| | 200 | __start_kprobe_blacklist = .; \ |
| | 201 | KEEP(*(_kprobe_blacklist)) \ |
| | 202 | __stop_kprobe_blacklist = .; |
| | 203 | #else |
| | 204 | #define KPROBE_BLACKLIST() |
| | 205 | #endif |
| | 206 | |
| | 207 | #ifdef CONFIG_FUNCTION_ERROR_INJECTION |
| | 208 | #define ERROR_INJECT_WHITELIST() STRUCT_ALIGN(); \ |
| | 209 | __start_error_injection_whitelist = .; \ |
| | 210 | KEEP(*(_error_injection_whitelist)) \ |
| | 211 | __stop_error_injection_whitelist = .; |
| | 212 | #else |
| | 213 | #define ERROR_INJECT_WHITELIST() |
| | 214 | #endif |
| | 215 | |
| | 216 | #ifdef CONFIG_EVENT_TRACING |
| | 217 | #define FTRACE_EVENTS() . = ALIGN(8); \ |
| | 218 | __start_ftrace_events = .; \ |
| | 219 | KEEP(*(_ftrace_events)) \ |
| | 220 | __stop_ftrace_events = .; \ |
| | 221 | __start_ftrace_eval_maps = .; \ |
| | 222 | KEEP(*(_ftrace_eval_map)) \ |
| | 223 | __stop_ftrace_eval_maps = .; |
| | 224 | #else |
| | 225 | #define FTRACE_EVENTS() |
| | 226 | #endif |
| | 227 | |
| | 228 | #ifdef CONFIG_TRACING |
| | 229 | #define TRACE_PRINTKS() __start___trace_bprintk_fmt = .; \ |
| | 230 | KEEP(*(__trace_printk_fmt)) /* Trace_printk fmt' pointer */ \ |
| | 231 | __stop___trace_bprintk_fmt = .; |
| | 232 | #define TRACEPOINT_STR() __start___tracepoint_str = .; \ |
| | 233 | KEEP(*(__tracepoint_str)) /* Trace_printk fmt' pointer */ \ |
| | 234 | __stop___tracepoint_str = .; |
| | 235 | #else |
| | 236 | #define TRACE_PRINTKS() |
| | 237 | #define TRACEPOINT_STR() |
| | 238 | #endif |
| | 239 | |
| | 240 | #ifdef CONFIG_FTRACE_SYSCALLS |
| | 241 | #define TRACE_SYSCALLS() . = ALIGN(8); \ |
| | 242 | __start_syscalls_metadata = .; \ |
| | 243 | KEEP(*(__syscalls_metadata)) \ |
| | 244 | __stop_syscalls_metadata = .; |
| | 245 | #else |
| | 246 | #define TRACE_SYSCALLS() |
| | 247 | #endif |
| | 248 | |
| | 249 | #ifdef CONFIG_BPF_EVENTS |
| | 250 | #define BPF_RAW_TP() STRUCT_ALIGN(); \ |
| | 251 | __start__bpf_raw_tp = .; \ |
| | 252 | KEEP(*(__bpf_raw_tp_map)) \ |
| | 253 | __stop__bpf_raw_tp = .; |
| | 254 | #else |
| | 255 | #define BPF_RAW_TP() |
| | 256 | #endif |
| | 257 | |
| | 258 | #ifdef CONFIG_SERIAL_EARLYCON |
| | 259 | #define EARLYCON_TABLE() . = ALIGN(8); \ |
| | 260 | __earlycon_table = .; \ |
| | 261 | KEEP(*(__earlycon_table)) \ |
| | 262 | __earlycon_table_end = .; |
| | 263 | #else |
| | 264 | #define EARLYCON_TABLE() |
| | 265 | #endif |
| | 266 | |
| | 267 | #ifdef CONFIG_SECURITY |
| | 268 | #define LSM_TABLE() . = ALIGN(8); \ |
| | 269 | __start_lsm_info = .; \ |
| | 270 | KEEP(*(.lsm_info.init)) \ |
| | 271 | __end_lsm_info = .; |
| | 272 | #define EARLY_LSM_TABLE() . = ALIGN(8); \ |
| | 273 | __start_early_lsm_info = .; \ |
| | 274 | KEEP(*(.early_lsm_info.init)) \ |
| | 275 | __end_early_lsm_info = .; |
| | 276 | #else |
| | 277 | #define LSM_TABLE() |
| | 278 | #define EARLY_LSM_TABLE() |
| | 279 | #endif |
| | 280 | |
| | 281 | #define ___OF_TABLE(cfg, name) _OF_TABLE_##cfg(name) |
| | 282 | #define __OF_TABLE(cfg, name) ___OF_TABLE(cfg, name) |
| | 283 | #define OF_TABLE(cfg, name) __OF_TABLE(IS_ENABLED(cfg), name) |
| | 284 | #define _OF_TABLE_0(name) |
| | 285 | #define _OF_TABLE_1(name) \ |
| | 286 | . = ALIGN(8); \ |
| | 287 | __##name##_of_table = .; \ |
| | 288 | KEEP(*(__##name##_of_table)) \ |
| | 289 | KEEP(*(__##name##_of_table_end)) |
| | 290 | |
| | 291 | #define TIMER_OF_TABLES() OF_TABLE(CONFIG_TIMER_OF, timer) |
| | 292 | #define IRQCHIP_OF_MATCH_TABLE() OF_TABLE(CONFIG_IRQCHIP, irqchip) |
| | 293 | #define CLK_OF_TABLES() OF_TABLE(CONFIG_COMMON_CLK, clk) |
| | 294 | #define RESERVEDMEM_OF_TABLES() OF_TABLE(CONFIG_OF_RESERVED_MEM, reservedmem) |
| | 295 | #define CPU_METHOD_OF_TABLES() OF_TABLE(CONFIG_SMP, cpu_method) |
| | 296 | #define CPUIDLE_METHOD_OF_TABLES() OF_TABLE(CONFIG_CPU_IDLE, cpuidle_method) |
| | 297 | |
| | 298 | #ifdef CONFIG_ACPI |
| | 299 | #define ACPI_PROBE_TABLE(name) \ |
| | 300 | . = ALIGN(8); \ |
| | 301 | __##name##_acpi_probe_table = .; \ |
| | 302 | KEEP(*(__##name##_acpi_probe_table)) \ |
| | 303 | __##name##_acpi_probe_table_end = .; |
| | 304 | #else |
| | 305 | #define ACPI_PROBE_TABLE(name) |
| | 306 | #endif |
| | 307 | |
| | 308 | #ifdef CONFIG_THERMAL |
| | 309 | #define THERMAL_TABLE(name) \ |
| | 310 | . = ALIGN(8); \ |
| | 311 | __##name##_thermal_table = .; \ |
| | 312 | KEEP(*(__##name##_thermal_table)) \ |
| | 313 | __##name##_thermal_table_end = .; |
| | 314 | #else |
| | 315 | #define THERMAL_TABLE(name) |
| | 316 | #endif |
| | 317 | |
| | 318 | #define KERNEL_DTB() \ |
| | 319 | STRUCT_ALIGN(); \ |
| | 320 | __dtb_start = .; \ |
| | 321 | KEEP(*(.dtb.init.rodata)) \ |
| | 322 | __dtb_end = .; |
| | 323 | |
| | 324 | /* |
| | 325 | * .data section |
| | 326 | */ |
| | 327 | #define DATA_DATA \ |
| | 328 | *(.xiptext) \ |
| | 329 | *(DATA_MAIN) \ |
| | 330 | *(.ref.data) \ |
| | 331 | *(.data..shared_aligned) /* percpu related */ \ |
| | 332 | MEM_KEEP(init.data*) \ |
| | 333 | MEM_KEEP(exit.data*) \ |
| | 334 | *(.data.unlikely) \ |
| | 335 | __start_once = .; \ |
| | 336 | *(.data.once) \ |
| | 337 | __end_once = .; \ |
| | 338 | STRUCT_ALIGN(); \ |
| | 339 | *(__tracepoints) \ |
| | 340 | /* implement dynamic printk debug */ \ |
| | 341 | . = ALIGN(8); \ |
| | 342 | __start___dyndbg = .; \ |
| | 343 | KEEP(*(__dyndbg)) \ |
| | 344 | __stop___dyndbg = .; \ |
| | 345 | LIKELY_PROFILE() \ |
| | 346 | BRANCH_PROFILE() \ |
| | 347 | TRACE_PRINTKS() \ |
| | 348 | BPF_RAW_TP() \ |
| | 349 | TRACEPOINT_STR() |
| | 350 | |
| | 351 | /* |
| | 352 | * Data section helpers |
| | 353 | */ |
| | 354 | #define NOSAVE_DATA \ |
| | 355 | . = ALIGN(PAGE_SIZE); \ |
| | 356 | __nosave_begin = .; \ |
| | 357 | *(.data..nosave) \ |
| | 358 | . = ALIGN(PAGE_SIZE); \ |
| | 359 | __nosave_end = .; |
| | 360 | |
| | 361 | #define PAGE_ALIGNED_DATA(page_align) \ |
| | 362 | . = ALIGN(page_align); \ |
| | 363 | *(.data..page_aligned) \ |
| | 364 | . = ALIGN(page_align); |
| | 365 | |
| | 366 | #define READ_MOSTLY_DATA(align) \ |
| | 367 | . = ALIGN(align); \ |
| | 368 | *(.data..read_mostly) \ |
| | 369 | . = ALIGN(align); |
| | 370 | |
| | 371 | #define CACHELINE_ALIGNED_DATA(align) \ |
| | 372 | . = ALIGN(align); \ |
| | 373 | *(.data..cacheline_aligned) |
| | 374 | |
| | 375 | #define INIT_TASK_DATA(align) \ |
| | 376 | . = ALIGN(align); \ |
| | 377 | __start_init_task = .; \ |
| | 378 | init_thread_union = .; \ |
| | 379 | init_stack = .; \ |
| | 380 | KEEP(*(.data..init_task)) \ |
| | 381 | KEEP(*(.data..init_thread_info)) \ |
| | 382 | . = __start_init_task + THREAD_SIZE; \ |
| | 383 | __end_init_task = .; |
| | 384 | |
| | 385 | #define JUMP_TABLE_DATA \ |
| | 386 | . = ALIGN(8); \ |
| | 387 | __start___jump_table = .; \ |
| | 388 | KEEP(*(__jump_table)) \ |
| | 389 | __stop___jump_table = .; |
| | 390 | |
| | 391 | #define STATIC_CALL_DATA \ |
| | 392 | . = ALIGN(8); \ |
| | 393 | __start_static_call_sites = .; \ |
| | 394 | KEEP(*(.static_call_sites)) \ |
| | 395 | __stop_static_call_sites = .; |
| | 396 | |
| | 397 | /* |
| | 398 | * Allow architectures to handle ro_after_init data on their |
| | 399 | * own by defining an empty RO_AFTER_INIT_DATA. |
| | 400 | */ |
| | 401 | #ifndef RO_AFTER_INIT_DATA |
| | 402 | #define RO_AFTER_INIT_DATA \ |
| | 403 | . = ALIGN(8); \ |
| | 404 | __start_ro_after_init = .; \ |
| | 405 | *(.data..ro_after_init) \ |
| | 406 | JUMP_TABLE_DATA \ |
| | 407 | STATIC_CALL_DATA \ |
| | 408 | __end_ro_after_init = .; |
| | 409 | #endif |
| | 410 | |
| | 411 | /* |
| | 412 | * Read only Data |
| | 413 | */ |
| | 414 | #define RO_DATA(align) \ |
| | 415 | . = ALIGN((align)); \ |
| | 416 | .rodata : AT(ADDR(.rodata) - LOAD_OFFSET) { \ |
| | 417 | __start_rodata = .; \ |
| | 418 | *(.rodata) *(.rodata.*) \ |
| | 419 | SCHED_DATA \ |
| | 420 | RO_AFTER_INIT_DATA /* Read only after init */ \ |
| | 421 | . = ALIGN(8); \ |
| | 422 | __start___tracepoints_ptrs = .; \ |
| | 423 | KEEP(*(__tracepoints_ptrs)) /* Tracepoints: pointer array */ \ |
| | 424 | __stop___tracepoints_ptrs = .; \ |
| | 425 | *(__tracepoints_strings)/* Tracepoints: strings */ \ |
| | 426 | } \ |
| | 427 | \ |
| | 428 | .rodata1 : AT(ADDR(.rodata1) - LOAD_OFFSET) { \ |
| | 429 | *(.rodata1) \ |
| | 430 | } \ |
| | 431 | \ |
| | 432 | /* PCI quirks */ \ |
| | 433 | .pci_fixup : AT(ADDR(.pci_fixup) - LOAD_OFFSET) { \ |
| | 434 | __start_pci_fixups_early = .; \ |
| | 435 | KEEP(*(.pci_fixup_early)) \ |
| | 436 | __end_pci_fixups_early = .; \ |
| | 437 | __start_pci_fixups_header = .; \ |
| | 438 | KEEP(*(.pci_fixup_header)) \ |
| | 439 | __end_pci_fixups_header = .; \ |
| | 440 | __start_pci_fixups_final = .; \ |
| | 441 | KEEP(*(.pci_fixup_final)) \ |
| | 442 | __end_pci_fixups_final = .; \ |
| | 443 | __start_pci_fixups_enable = .; \ |
| | 444 | KEEP(*(.pci_fixup_enable)) \ |
| | 445 | __end_pci_fixups_enable = .; \ |
| | 446 | __start_pci_fixups_resume = .; \ |
| | 447 | KEEP(*(.pci_fixup_resume)) \ |
| | 448 | __end_pci_fixups_resume = .; \ |
| | 449 | __start_pci_fixups_resume_early = .; \ |
| | 450 | KEEP(*(.pci_fixup_resume_early)) \ |
| | 451 | __end_pci_fixups_resume_early = .; \ |
| | 452 | __start_pci_fixups_suspend = .; \ |
| | 453 | KEEP(*(.pci_fixup_suspend)) \ |
| | 454 | __end_pci_fixups_suspend = .; \ |
| | 455 | __start_pci_fixups_suspend_late = .; \ |
| | 456 | KEEP(*(.pci_fixup_suspend_late)) \ |
| | 457 | __end_pci_fixups_suspend_late = .; \ |
| | 458 | } \ |
| | 459 | \ |
| | 460 | /* Built-in firmware blobs */ \ |
| | 461 | .builtin_fw : AT(ADDR(.builtin_fw) - LOAD_OFFSET) { \ |
| | 462 | __start_builtin_fw = .; \ |
| | 463 | KEEP(*(.builtin_fw)) \ |
| | 464 | __end_builtin_fw = .; \ |
| | 465 | } \ |
| | 466 | \ |
| | 467 | TRACEDATA \ |
| | 468 | \ |
| | 469 | /* Kernel symbol table: Normal symbols */ \ |
| | 470 | __ksymtab : AT(ADDR(__ksymtab) - LOAD_OFFSET) { \ |
| | 471 | __start___ksymtab = .; \ |
| | 472 | KEEP(*(SORT(___ksymtab+*))) \ |
| | 473 | __stop___ksymtab = .; \ |
| | 474 | } \ |
| | 475 | \ |
| | 476 | /* Kernel symbol table: GPL-only symbols */ \ |
| | 477 | __ksymtab_gpl : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) { \ |
| | 478 | __start___ksymtab_gpl = .; \ |
| | 479 | KEEP(*(SORT(___ksymtab_gpl+*))) \ |
| | 480 | __stop___ksymtab_gpl = .; \ |
| | 481 | } \ |
| | 482 | \ |
| | 483 | /* Kernel symbol table: Normal unused symbols */ \ |
| | 484 | __ksymtab_unused : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) { \ |
| | 485 | __start___ksymtab_unused = .; \ |
| | 486 | KEEP(*(SORT(___ksymtab_unused+*))) \ |
| | 487 | __stop___ksymtab_unused = .; \ |
| | 488 | } \ |
| | 489 | \ |
| | 490 | /* Kernel symbol table: GPL-only unused symbols */ \ |
| | 491 | __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \ |
| | 492 | __start___ksymtab_unused_gpl = .; \ |
| | 493 | KEEP(*(SORT(___ksymtab_unused_gpl+*))) \ |
| | 494 | __stop___ksymtab_unused_gpl = .; \ |
| | 495 | } \ |
| | 496 | \ |
| | 497 | /* Kernel symbol table: GPL-future-only symbols */ \ |
| | 498 | __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \ |
| | 499 | __start___ksymtab_gpl_future = .; \ |
| | 500 | KEEP(*(SORT(___ksymtab_gpl_future+*))) \ |
| | 501 | __stop___ksymtab_gpl_future = .; \ |
| | 502 | } \ |
| | 503 | \ |
| | 504 | /* Kernel symbol table: Normal symbols */ \ |
| | 505 | __kcrctab : AT(ADDR(__kcrctab) - LOAD_OFFSET) { \ |
| | 506 | __start___kcrctab = .; \ |
| | 507 | KEEP(*(SORT(___kcrctab+*))) \ |
| | 508 | __stop___kcrctab = .; \ |
| | 509 | } \ |
| | 510 | \ |
| | 511 | /* Kernel symbol table: GPL-only symbols */ \ |
| | 512 | __kcrctab_gpl : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) { \ |
| | 513 | __start___kcrctab_gpl = .; \ |
| | 514 | KEEP(*(SORT(___kcrctab_gpl+*))) \ |
| | 515 | __stop___kcrctab_gpl = .; \ |
| | 516 | } \ |
| | 517 | \ |
| | 518 | /* Kernel symbol table: Normal unused symbols */ \ |
| | 519 | __kcrctab_unused : AT(ADDR(__kcrctab_unused) - LOAD_OFFSET) { \ |
| | 520 | __start___kcrctab_unused = .; \ |
| | 521 | KEEP(*(SORT(___kcrctab_unused+*))) \ |
| | 522 | __stop___kcrctab_unused = .; \ |
| | 523 | } \ |
| | 524 | \ |
| | 525 | /* Kernel symbol table: GPL-only unused symbols */ \ |
| | 526 | __kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \ |
| | 527 | __start___kcrctab_unused_gpl = .; \ |
| | 528 | KEEP(*(SORT(___kcrctab_unused_gpl+*))) \ |
| | 529 | __stop___kcrctab_unused_gpl = .; \ |
| | 530 | } \ |
| | 531 | \ |
| | 532 | /* Kernel symbol table: GPL-future-only symbols */ \ |
| | 533 | __kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \ |
| | 534 | __start___kcrctab_gpl_future = .; \ |
| | 535 | KEEP(*(SORT(___kcrctab_gpl_future+*))) \ |
| | 536 | __stop___kcrctab_gpl_future = .; \ |
| | 537 | } \ |
| | 538 | \ |
| | 539 | /* Kernel symbol table: strings */ \ |
| | 540 | __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) { \ |
| | 541 | *(__ksymtab_strings) \ |
| | 542 | } \ |
| | 543 | \ |
| | 544 | /* __*init sections */ \ |
| | 545 | __init_rodata : AT(ADDR(__init_rodata) - LOAD_OFFSET) { \ |
| | 546 | *(.ref.rodata) \ |
| | 547 | MEM_KEEP(init.rodata) \ |
| | 548 | MEM_KEEP(exit.rodata) \ |
| | 549 | } \ |
| | 550 | \ |
| | 551 | /* Built-in module parameters. */ \ |
| | 552 | __param : AT(ADDR(__param) - LOAD_OFFSET) { \ |
| | 553 | __start___param = .; \ |
| | 554 | KEEP(*(__param)) \ |
| | 555 | __stop___param = .; \ |
| | 556 | } \ |
| | 557 | \ |
| | 558 | /* Built-in module versions. */ \ |
| | 559 | __modver : AT(ADDR(__modver) - LOAD_OFFSET) { \ |
| | 560 | __start___modver = .; \ |
| | 561 | KEEP(*(__modver)) \ |
| | 562 | __stop___modver = .; \ |
| | 563 | } \ |
| | 564 | \ |
| | 565 | RO_EXCEPTION_TABLE \ |
| | 566 | NOTES \ |
| | 567 | BTF \ |
| | 568 | \ |
| | 569 | . = ALIGN((align)); \ |
| | 570 | __end_rodata = .; |
| | 571 | |
| | 572 | /* |
| | 573 | * Non-instrumentable text section |
| | 574 | */ |
| | 575 | #define NOINSTR_TEXT \ |
| | 576 | ALIGN_FUNCTION(); \ |
| | 577 | __noinstr_text_start = .; \ |
| | 578 | *(.noinstr.text) \ |
| | 579 | __noinstr_text_end = .; |
| | 580 | |
| | 581 | /* |
| | 582 | * .text section. Map to function alignment to avoid address changes |
| | 583 | * during second ld run in second ld pass when generating System.map |
| | 584 | * |
| | 585 | * TEXT_MAIN here will match .text.fixup and .text.unlikely if dead |
| | 586 | * code elimination is enabled, so these sections should be converted |
| | 587 | * to use ".." first. |
| | 588 | */ |
| | 589 | #define TEXT_TEXT \ |
| | 590 | ALIGN_FUNCTION(); \ |
| | 591 | *(.text.hot TEXT_MAIN .text.fixup .text.unlikely) \ |
| | 592 | NOINSTR_TEXT \ |
| | 593 | *(.text..refcount) \ |
| | 594 | *(.ref.text) \ |
| | 595 | MEM_KEEP(init.text*) \ |
| | 596 | MEM_KEEP(exit.text*) \ |
| | 597 | |
| | 598 | |
| | 599 | /* sched.text is aling to function alignment to secure we have same |
| | 600 | * address even at second ld pass when generating System.map */ |
| | 601 | #define SCHED_TEXT \ |
| | 602 | ALIGN_FUNCTION(); \ |
| | 603 | __sched_text_start = .; \ |
| | 604 | *(.sched.text) \ |
| | 605 | __sched_text_end = .; |
| | 606 | |
| | 607 | /* spinlock.text is aling to function alignment to secure we have same |
| | 608 | * address even at second ld pass when generating System.map */ |
| | 609 | #define LOCK_TEXT \ |
| | 610 | ALIGN_FUNCTION(); \ |
| | 611 | __lock_text_start = .; \ |
| | 612 | *(.spinlock.text) \ |
| | 613 | __lock_text_end = .; |
| | 614 | |
| | 615 | #define CPUIDLE_TEXT \ |
| | 616 | ALIGN_FUNCTION(); \ |
| | 617 | __cpuidle_text_start = .; \ |
| | 618 | *(.cpuidle.text) \ |
| | 619 | __cpuidle_text_end = .; |
| | 620 | |
| | 621 | #define KPROBES_TEXT \ |
| | 622 | ALIGN_FUNCTION(); \ |
| | 623 | __kprobes_text_start = .; \ |
| | 624 | *(.kprobes.text) \ |
| | 625 | __kprobes_text_end = .; |
| | 626 | |
| | 627 | #define ENTRY_TEXT \ |
| | 628 | ALIGN_FUNCTION(); \ |
| | 629 | __entry_text_start = .; \ |
| | 630 | *(.entry.text) \ |
| | 631 | __entry_text_end = .; |
| | 632 | |
| | 633 | #define IRQENTRY_TEXT \ |
| | 634 | ALIGN_FUNCTION(); \ |
| | 635 | __irqentry_text_start = .; \ |
| | 636 | *(.irqentry.text) \ |
| | 637 | __irqentry_text_end = .; |
| | 638 | |
| | 639 | #define SOFTIRQENTRY_TEXT \ |
| | 640 | ALIGN_FUNCTION(); \ |
| | 641 | __softirqentry_text_start = .; \ |
| | 642 | *(.softirqentry.text) \ |
| | 643 | __softirqentry_text_end = .; |
| | 644 | |
| | 645 | /* Section used for early init (in .S files) */ |
| | 646 | #define HEAD_TEXT KEEP(*(.head.text)) |
| | 647 | |
| | 648 | #define HEAD_TEXT_SECTION \ |
| | 649 | .head.text : AT(ADDR(.head.text) - LOAD_OFFSET) { \ |
| | 650 | HEAD_TEXT \ |
| | 651 | } |
| | 652 | |
| | 653 | /* |
| | 654 | * Exception table |
| | 655 | */ |
| | 656 | #define EXCEPTION_TABLE(align) \ |
| | 657 | . = ALIGN(align); \ |
| | 658 | __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) { \ |
| | 659 | __start___ex_table = .; \ |
| | 660 | KEEP(*(__ex_table)) \ |
| | 661 | __stop___ex_table = .; \ |
| | 662 | } |
| | 663 | |
| | 664 | /* |
| | 665 | * .BTF |
| | 666 | */ |
| | 667 | #ifdef CONFIG_DEBUG_INFO_BTF |
| | 668 | #define BTF \ |
| | 669 | .BTF : AT(ADDR(.BTF) - LOAD_OFFSET) { \ |
| | 670 | __start_BTF = .; \ |
| | 671 | *(.BTF) \ |
| | 672 | __stop_BTF = .; \ |
| | 673 | } \ |
| | 674 | . = ALIGN(4); \ |
| | 675 | .BTF_ids : AT(ADDR(.BTF_ids) - LOAD_OFFSET) { \ |
| | 676 | *(.BTF_ids) \ |
| | 677 | } |
| | 678 | #else |
| | 679 | #define BTF |
| | 680 | #endif |
| | 681 | |
| | 682 | /* |
| | 683 | * Init task |
| | 684 | */ |
| | 685 | #define INIT_TASK_DATA_SECTION(align) \ |
| | 686 | . = ALIGN(align); \ |
| | 687 | .data..init_task : AT(ADDR(.data..init_task) - LOAD_OFFSET) { \ |
| | 688 | INIT_TASK_DATA(align) \ |
| | 689 | } |
| | 690 | |
| | 691 | #ifdef CONFIG_CONSTRUCTORS |
| | 692 | #define KERNEL_CTORS() . = ALIGN(8); \ |
| | 693 | __ctors_start = .; \ |
| | 694 | KEEP(*(.ctors)) \ |
| | 695 | KEEP(*(SORT(.init_array.*))) \ |
| | 696 | KEEP(*(.init_array)) \ |
| | 697 | __ctors_end = .; |
| | 698 | #else |
| | 699 | #define KERNEL_CTORS() |
| | 700 | #endif |
| | 701 | |
| | 702 | /* init and exit section handling */ |
| | 703 | #define INIT_DATA \ |
| | 704 | KEEP(*(SORT(___kentry+*))) \ |
| | 705 | *(.init.data init.data.*) \ |
| | 706 | MEM_DISCARD(init.data*) \ |
| | 707 | KERNEL_CTORS() \ |
| | 708 | MCOUNT_REC() \ |
| | 709 | *(.init.rodata .init.rodata.*) \ |
| | 710 | FTRACE_EVENTS() \ |
| | 711 | TRACE_SYSCALLS() \ |
| | 712 | KPROBE_BLACKLIST() \ |
| | 713 | ERROR_INJECT_WHITELIST() \ |
| | 714 | MEM_DISCARD(init.rodata) \ |
| | 715 | CLK_OF_TABLES() \ |
| | 716 | RESERVEDMEM_OF_TABLES() \ |
| | 717 | TIMER_OF_TABLES() \ |
| | 718 | CPU_METHOD_OF_TABLES() \ |
| | 719 | CPUIDLE_METHOD_OF_TABLES() \ |
| | 720 | KERNEL_DTB() \ |
| | 721 | IRQCHIP_OF_MATCH_TABLE() \ |
| | 722 | ACPI_PROBE_TABLE(irqchip) \ |
| | 723 | ACPI_PROBE_TABLE(timer) \ |
| | 724 | THERMAL_TABLE(governor) \ |
| | 725 | EARLYCON_TABLE() \ |
| | 726 | LSM_TABLE() \ |
| | 727 | EARLY_LSM_TABLE() |
| | 728 | |
| | 729 | #define INIT_TEXT \ |
| | 730 | *(.init.text .init.text.*) \ |
| | 731 | *(.text.startup) \ |
| | 732 | MEM_DISCARD(init.text*) |
| | 733 | |
| | 734 | #define EXIT_DATA \ |
| | 735 | *(.exit.data .exit.data.*) \ |
| | 736 | *(.fini_array .fini_array.*) \ |
| | 737 | *(.dtors .dtors.*) \ |
| | 738 | MEM_DISCARD(exit.data*) \ |
| | 739 | MEM_DISCARD(exit.rodata*) |
| | 740 | |
| | 741 | #define EXIT_TEXT \ |
| | 742 | *(.exit.text) \ |
| | 743 | *(.text.exit) \ |
| | 744 | MEM_DISCARD(exit.text) |
| | 745 | |
| | 746 | #define EXIT_CALL \ |
| | 747 | *(.exitcall.exit) |
| | 748 | |
| | 749 | /* |
| | 750 | * bss (Block Started by Symbol) - uninitialized data |
| | 751 | * zeroed during startup |
| | 752 | */ |
| | 753 | #define SBSS(sbss_align) \ |
| | 754 | . = ALIGN(sbss_align); \ |
| | 755 | .sbss : AT(ADDR(.sbss) - LOAD_OFFSET) { \ |
| | 756 | *(.dynsbss) \ |
| | 757 | *(SBSS_MAIN) \ |
| | 758 | *(.scommon) \ |
| | 759 | } |
| | 760 | |
| | 761 | /* |
| | 762 | * Allow archectures to redefine BSS_FIRST_SECTIONS to add extra |
| | 763 | * sections to the front of bss. |
| | 764 | */ |
| | 765 | #ifndef BSS_FIRST_SECTIONS |
| | 766 | #define BSS_FIRST_SECTIONS |
| | 767 | #endif |
| | 768 | |
| | 769 | #define BSS(bss_align) \ |
| | 770 | . = ALIGN(bss_align); \ |
| | 771 | .bss : AT(ADDR(.bss) - LOAD_OFFSET) { \ |
| | 772 | BSS_FIRST_SECTIONS \ |
| | 773 | . = ALIGN(PAGE_SIZE); \ |
| | 774 | *(.bss..page_aligned) \ |
| | 775 | . = ALIGN(PAGE_SIZE); \ |
| | 776 | *(.dynbss) \ |
| | 777 | *(BSS_MAIN) \ |
| | 778 | *(COMMON) \ |
| | 779 | } |
| | 780 | |
| | 781 | /* |
| | 782 | * DWARF debug sections. |
| | 783 | * Symbols in the DWARF debugging sections are relative to |
| | 784 | * the beginning of the section so we begin them at 0. |
| | 785 | */ |
| | 786 | #define DWARF_DEBUG \ |
| | 787 | /* DWARF 1 */ \ |
| | 788 | .debug 0 : { *(.debug) } \ |
| | 789 | .line 0 : { *(.line) } \ |
| | 790 | /* GNU DWARF 1 extensions */ \ |
| | 791 | .debug_srcinfo 0 : { *(.debug_srcinfo) } \ |
| | 792 | .debug_sfnames 0 : { *(.debug_sfnames) } \ |
| | 793 | /* DWARF 1.1 and DWARF 2 */ \ |
| | 794 | .debug_aranges 0 : { *(.debug_aranges) } \ |
| | 795 | .debug_pubnames 0 : { *(.debug_pubnames) } \ |
| | 796 | /* DWARF 2 */ \ |
| | 797 | .debug_info 0 : { *(.debug_info \ |
| | 798 | .gnu.linkonce.wi.*) } \ |
| | 799 | .debug_abbrev 0 : { *(.debug_abbrev) } \ |
| | 800 | .debug_line 0 : { *(.debug_line) } \ |
| | 801 | .debug_frame 0 : { *(.debug_frame) } \ |
| | 802 | .debug_str 0 : { *(.debug_str) } \ |
| | 803 | .debug_loc 0 : { *(.debug_loc) } \ |
| | 804 | .debug_macinfo 0 : { *(.debug_macinfo) } \ |
| | 805 | .debug_pubtypes 0 : { *(.debug_pubtypes) } \ |
| | 806 | /* DWARF 3 */ \ |
| | 807 | .debug_ranges 0 : { *(.debug_ranges) } \ |
| | 808 | /* SGI/MIPS DWARF 2 extensions */ \ |
| | 809 | .debug_weaknames 0 : { *(.debug_weaknames) } \ |
| | 810 | .debug_funcnames 0 : { *(.debug_funcnames) } \ |
| | 811 | .debug_typenames 0 : { *(.debug_typenames) } \ |
| | 812 | .debug_varnames 0 : { *(.debug_varnames) } \ |
| | 813 | /* GNU DWARF 2 extensions */ \ |
| | 814 | .debug_gnu_pubnames 0 : { *(.debug_gnu_pubnames) } \ |
| | 815 | .debug_gnu_pubtypes 0 : { *(.debug_gnu_pubtypes) } \ |
| | 816 | /* DWARF 4 */ \ |
| | 817 | .debug_types 0 : { *(.debug_types) } \ |
| | 818 | /* DWARF 5 */ \ |
| | 819 | .debug_macro 0 : { *(.debug_macro) } \ |
| | 820 | .debug_addr 0 : { *(.debug_addr) } |
| | 821 | |
| | 822 | /* Stabs debugging sections. */ |
| | 823 | #define STABS_DEBUG \ |
| | 824 | .stab 0 : { *(.stab) } \ |
| | 825 | .stabstr 0 : { *(.stabstr) } \ |
| | 826 | .stab.excl 0 : { *(.stab.excl) } \ |
| | 827 | .stab.exclstr 0 : { *(.stab.exclstr) } \ |
| | 828 | .stab.index 0 : { *(.stab.index) } \ |
| | 829 | .stab.indexstr 0 : { *(.stab.indexstr) } \ |
| | 830 | .comment 0 : { *(.comment) } |
| | 831 | |
| | 832 | #ifdef CONFIG_GENERIC_BUG |
| | 833 | #define BUG_TABLE \ |
| | 834 | . = ALIGN(8); \ |
| | 835 | __bug_table : AT(ADDR(__bug_table) - LOAD_OFFSET) { \ |
| | 836 | __start___bug_table = .; \ |
| | 837 | KEEP(*(__bug_table)) \ |
| | 838 | __stop___bug_table = .; \ |
| | 839 | } |
| | 840 | #else |
| | 841 | #define BUG_TABLE |
| | 842 | #endif |
| | 843 | |
| | 844 | #ifdef CONFIG_UNWINDER_ORC |
| | 845 | #define ORC_UNWIND_TABLE \ |
| | 846 | . = ALIGN(4); \ |
| | 847 | .orc_unwind_ip : AT(ADDR(.orc_unwind_ip) - LOAD_OFFSET) { \ |
| | 848 | __start_orc_unwind_ip = .; \ |
| | 849 | KEEP(*(.orc_unwind_ip)) \ |
| | 850 | __stop_orc_unwind_ip = .; \ |
| | 851 | } \ |
| | 852 | . = ALIGN(2); \ |
| | 853 | .orc_unwind : AT(ADDR(.orc_unwind) - LOAD_OFFSET) { \ |
| | 854 | __start_orc_unwind = .; \ |
| | 855 | KEEP(*(.orc_unwind)) \ |
| | 856 | __stop_orc_unwind = .; \ |
| | 857 | } \ |
| | 858 | . = ALIGN(4); \ |
| | 859 | .orc_lookup : AT(ADDR(.orc_lookup) - LOAD_OFFSET) { \ |
| | 860 | orc_lookup = .; \ |
| | 861 | . += (((SIZEOF(.text) + LOOKUP_BLOCK_SIZE - 1) / \ |
| | 862 | LOOKUP_BLOCK_SIZE) + 1) * 4; \ |
| | 863 | orc_lookup_end = .; \ |
| | 864 | } |
| | 865 | #else |
| | 866 | #define ORC_UNWIND_TABLE |
| | 867 | #endif |
| | 868 | |
| | 869 | #ifdef CONFIG_PM_TRACE |
| | 870 | #define TRACEDATA \ |
| | 871 | . = ALIGN(4); \ |
| | 872 | .tracedata : AT(ADDR(.tracedata) - LOAD_OFFSET) { \ |
| | 873 | __tracedata_start = .; \ |
| | 874 | KEEP(*(.tracedata)) \ |
| | 875 | __tracedata_end = .; \ |
| | 876 | } |
| | 877 | #else |
| | 878 | #define TRACEDATA |
| | 879 | #endif |
| | 880 | |
| | 881 | #define NOTES \ |
| | 882 | .notes : AT(ADDR(.notes) - LOAD_OFFSET) { \ |
| | 883 | __start_notes = .; \ |
| | 884 | KEEP(*(.note.*)) \ |
| | 885 | __stop_notes = .; \ |
| | 886 | } NOTES_HEADERS \ |
| | 887 | NOTES_HEADERS_RESTORE |
| | 888 | |
| | 889 | #define INIT_SETUP(initsetup_align) \ |
| | 890 | . = ALIGN(initsetup_align); \ |
| | 891 | __setup_start = .; \ |
| | 892 | KEEP(*(.init.setup)) \ |
| | 893 | __setup_end = .; |
| | 894 | |
| | 895 | #define INIT_CALLS_LEVEL(level) \ |
| | 896 | __initcall##level##_start = .; \ |
| | 897 | KEEP(*(.initcall##level##.init)) \ |
| | 898 | KEEP(*(.initcall##level##s.init)) \ |
| | 899 | |
| | 900 | #define INIT_CALLS \ |
| | 901 | __initcall_start = .; \ |
| | 902 | KEEP(*(.initcallearly.init)) \ |
| | 903 | INIT_CALLS_LEVEL(0) \ |
| | 904 | INIT_CALLS_LEVEL(1) \ |
| | 905 | INIT_CALLS_LEVEL(2) \ |
| | 906 | INIT_CALLS_LEVEL(3) \ |
| | 907 | INIT_CALLS_LEVEL(4) \ |
| | 908 | INIT_CALLS_LEVEL(5) \ |
| | 909 | INIT_CALLS_LEVEL(rootfs) \ |
| | 910 | INIT_CALLS_LEVEL(6) \ |
| | 911 | INIT_CALLS_LEVEL(7) \ |
| | 912 | __initcall_end = .; |
| | 913 | |
| | 914 | #define CON_INITCALL \ |
| | 915 | __con_initcall_start = .; \ |
| | 916 | KEEP(*(.con_initcall.init)) \ |
| | 917 | __con_initcall_end = .; |
| | 918 | |
| | 919 | #ifdef CONFIG_BLK_DEV_INITRD |
| | 920 | #define INIT_RAM_FS \ |
| | 921 | . = ALIGN(4); \ |
| | 922 | __initramfs_start = .; \ |
| | 923 | KEEP(*(.init.ramfs)) \ |
| | 924 | . = ALIGN(8); \ |
| | 925 | KEEP(*(.init.ramfs.info)) |
| | 926 | #else |
| | 927 | #define INIT_RAM_FS |
| | 928 | #endif |
| | 929 | |
| | 930 | /* |
| | 931 | * Memory encryption operates on a page basis. Since we need to clear |
| | 932 | * the memory encryption mask for this section, it needs to be aligned |
| | 933 | * on a page boundary and be a page-size multiple in length. |
| | 934 | * |
| | 935 | * Note: We use a separate section so that only this section gets |
| | 936 | * decrypted to avoid exposing more than we wish. |
| | 937 | */ |
| | 938 | #ifdef CONFIG_AMD_MEM_ENCRYPT |
| | 939 | #define PERCPU_DECRYPTED_SECTION \ |
| | 940 | . = ALIGN(PAGE_SIZE); \ |
| | 941 | *(.data..percpu..decrypted) \ |
| | 942 | . = ALIGN(PAGE_SIZE); |
| | 943 | #else |
| | 944 | #define PERCPU_DECRYPTED_SECTION |
| | 945 | #endif |
| | 946 | |
| | 947 | |
| | 948 | /* |
| | 949 | * Default discarded sections. |
| | 950 | * |
| | 951 | * Some archs want to discard exit text/data at runtime rather than |
| | 952 | * link time due to cross-section references such as alt instructions, |
| | 953 | * bug table, eh_frame, etc. DISCARDS must be the last of output |
| | 954 | * section definitions so that such archs put those in earlier section |
| | 955 | * definitions. |
| | 956 | */ |
| | 957 | #ifdef RUNTIME_DISCARD_EXIT |
| | 958 | #define EXIT_DISCARDS |
| | 959 | #else |
| | 960 | #define EXIT_DISCARDS \ |
| | 961 | EXIT_TEXT \ |
| | 962 | EXIT_DATA |
| | 963 | #endif |
| | 964 | |
| | 965 | #define DISCARDS \ |
| | 966 | /DISCARD/ : { \ |
| | 967 | EXIT_DISCARDS \ |
| | 968 | EXIT_CALL \ |
| | 969 | *(.discard) \ |
| | 970 | *(.discard.*) \ |
| | 971 | *(.modinfo) \ |
| | 972 | } |
| | 973 | |
| | 974 | /** |
| | 975 | * PERCPU_INPUT - the percpu input sections |
| | 976 | * @cacheline: cacheline size |
| | 977 | * |
| | 978 | * The core percpu section names and core symbols which do not rely |
| | 979 | * directly upon load addresses. |
| | 980 | * |
| | 981 | * @cacheline is used to align subsections to avoid false cacheline |
| | 982 | * sharing between subsections for different purposes. |
| | 983 | */ |
| | 984 | #define PERCPU_INPUT(cacheline) \ |
| | 985 | __per_cpu_start = .; \ |
| | 986 | *(.data..percpu..first) \ |
| | 987 | . = ALIGN(PAGE_SIZE); \ |
| | 988 | *(.data..percpu..page_aligned) \ |
| | 989 | . = ALIGN(cacheline); \ |
| | 990 | *(.data..percpu..read_mostly) \ |
| | 991 | . = ALIGN(cacheline); \ |
| | 992 | *(.data..percpu) \ |
| | 993 | *(.data..percpu..shared_aligned) \ |
| | 994 | PERCPU_DECRYPTED_SECTION \ |
| | 995 | __per_cpu_end = .; |
| | 996 | |
| | 997 | /** |
| | 998 | * PERCPU_VADDR - define output section for percpu area |
| | 999 | * @cacheline: cacheline size |
| | 1000 | * @vaddr: explicit base address (optional) |
| | 1001 | * @phdr: destination PHDR (optional) |
| | 1002 | * |
| | 1003 | * Macro which expands to output section for percpu area. |
| | 1004 | * |
| | 1005 | * @cacheline is used to align subsections to avoid false cacheline |
| | 1006 | * sharing between subsections for different purposes. |
| | 1007 | * |
| | 1008 | * If @vaddr is not blank, it specifies explicit base address and all |
| | 1009 | * percpu symbols will be offset from the given address. If blank, |
| | 1010 | * @vaddr always equals @laddr + LOAD_OFFSET. |
| | 1011 | * |
| | 1012 | * @phdr defines the output PHDR to use if not blank. Be warned that |
| | 1013 | * output PHDR is sticky. If @phdr is specified, the next output |
| | 1014 | * section in the linker script will go there too. @phdr should have |
| | 1015 | * a leading colon. |
| | 1016 | * |
| | 1017 | * Note that this macros defines __per_cpu_load as an absolute symbol. |
| | 1018 | * If there is no need to put the percpu section at a predetermined |
| | 1019 | * address, use PERCPU_SECTION. |
| | 1020 | */ |
| | 1021 | #define PERCPU_VADDR(cacheline, vaddr, phdr) \ |
| | 1022 | __per_cpu_load = .; \ |
| | 1023 | .data..percpu vaddr : AT(__per_cpu_load - LOAD_OFFSET) { \ |
| | 1024 | PERCPU_INPUT(cacheline) \ |
| | 1025 | } phdr \ |
| | 1026 | . = __per_cpu_load + SIZEOF(.data..percpu); |
| | 1027 | |
| | 1028 | /** |
| | 1029 | * PERCPU_SECTION - define output section for percpu area, simple version |
| | 1030 | * @cacheline: cacheline size |
| | 1031 | * |
| | 1032 | * Align to PAGE_SIZE and outputs output section for percpu area. This |
| | 1033 | * macro doesn't manipulate @vaddr or @phdr and __per_cpu_load and |
| | 1034 | * __per_cpu_start will be identical. |
| | 1035 | * |
| | 1036 | * This macro is equivalent to ALIGN(PAGE_SIZE); PERCPU_VADDR(@cacheline,,) |
| | 1037 | * except that __per_cpu_load is defined as a relative symbol against |
| | 1038 | * .data..percpu which is required for relocatable x86_32 configuration. |
| | 1039 | */ |
| | 1040 | #define PERCPU_SECTION(cacheline) \ |
| | 1041 | . = ALIGN(PAGE_SIZE); \ |
| | 1042 | .data..percpu : AT(ADDR(.data..percpu) - LOAD_OFFSET) { \ |
| | 1043 | __per_cpu_load = .; \ |
| | 1044 | PERCPU_INPUT(cacheline) \ |
| | 1045 | } |
| | 1046 | |
| | 1047 | |
| | 1048 | /* |
| | 1049 | * Definition of the high level *_SECTION macros |
| | 1050 | * They will fit only a subset of the architectures |
| | 1051 | */ |
| | 1052 | |
| | 1053 | |
| | 1054 | /* |
| | 1055 | * Writeable data. |
| | 1056 | * All sections are combined in a single .data section. |
| | 1057 | * The sections following CONSTRUCTORS are arranged so their |
| | 1058 | * typical alignment matches. |
| | 1059 | * A cacheline is typical/always less than a PAGE_SIZE so |
| | 1060 | * the sections that has this restriction (or similar) |
| | 1061 | * is located before the ones requiring PAGE_SIZE alignment. |
| | 1062 | * NOSAVE_DATA starts and ends with a PAGE_SIZE alignment which |
| | 1063 | * matches the requirement of PAGE_ALIGNED_DATA. |
| | 1064 | * |
| | 1065 | * use 0 as page_align if page_aligned data is not used */ |
| | 1066 | #define RW_DATA(cacheline, pagealigned, inittask) \ |
| | 1067 | . = ALIGN(PAGE_SIZE); \ |
| | 1068 | .data : AT(ADDR(.data) - LOAD_OFFSET) { \ |
| | 1069 | INIT_TASK_DATA(inittask) \ |
| | 1070 | NOSAVE_DATA \ |
| | 1071 | PAGE_ALIGNED_DATA(pagealigned) \ |
| | 1072 | CACHELINE_ALIGNED_DATA(cacheline) \ |
| | 1073 | READ_MOSTLY_DATA(cacheline) \ |
| | 1074 | DATA_DATA \ |
| | 1075 | CONSTRUCTORS \ |
| | 1076 | } \ |
| | 1077 | BUG_TABLE \ |
| | 1078 | |
| | 1079 | #define INIT_TEXT_SECTION(inittext_align) \ |
| | 1080 | . = ALIGN(inittext_align); \ |
| | 1081 | .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) { \ |
| | 1082 | _sinittext = .; \ |
| | 1083 | INIT_TEXT \ |
| | 1084 | _einittext = .; \ |
| | 1085 | } |
| | 1086 | |
| | 1087 | #define INIT_DATA_SECTION(initsetup_align) \ |
| | 1088 | .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) { \ |
| | 1089 | INIT_DATA \ |
| | 1090 | INIT_SETUP(initsetup_align) \ |
| | 1091 | INIT_CALLS \ |
| | 1092 | CON_INITCALL \ |
| | 1093 | INIT_RAM_FS \ |
| | 1094 | } |
| | 1095 | |
| | 1096 | #define BSS_SECTION(sbss_align, bss_align, stop_align) \ |
| | 1097 | . = ALIGN(sbss_align); \ |
| | 1098 | __bss_start = .; \ |
| | 1099 | SBSS(sbss_align) \ |
| | 1100 | BSS(bss_align) \ |
| | 1101 | . = ALIGN(stop_align); \ |
| | 1102 | __bss_stop = .; |
projects / mirror_ubuntu-jammy-kernel.git / blame_incremental