1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53#ifndef LOAD_OFFSET
54#define LOAD_OFFSET 0
55#endif
56
57
58#define ALIGN_FUNCTION() . = ALIGN(8)
59
60
61
62
63
64
65
66
67
68
69#ifdef CONFIG_LD_DEAD_CODE_DATA_ELIMINATION
70#define TEXT_MAIN .text .text.[0-9a-zA-Z_]*
71#define DATA_MAIN .data .data.[0-9a-zA-Z_]* .data..LPBX*
72#define SDATA_MAIN .sdata .sdata.[0-9a-zA-Z_]*
73#define RODATA_MAIN .rodata .rodata.[0-9a-zA-Z_]*
74#define BSS_MAIN .bss .bss.[0-9a-zA-Z_]*
75#define SBSS_MAIN .sbss .sbss.[0-9a-zA-Z_]*
76#else
77#define TEXT_MAIN .text
78#define DATA_MAIN .data
79#define SDATA_MAIN .sdata
80#define RODATA_MAIN .rodata
81#define BSS_MAIN .bss
82#define SBSS_MAIN .sbss
83#endif
84
85
86
87
88
89#define STRUCT_ALIGNMENT 32
90#define STRUCT_ALIGN() . = ALIGN(STRUCT_ALIGNMENT)
91
92
93
94
95
96#ifdef CONFIG_HOTPLUG_CPU
97#define CPU_KEEP(sec) *(.cpu##sec)
98#define CPU_DISCARD(sec)
99#else
100#define CPU_KEEP(sec)
101#define CPU_DISCARD(sec) *(.cpu##sec)
102#endif
103
104#if defined(CONFIG_MEMORY_HOTPLUG)
105#define MEM_KEEP(sec) *(.mem##sec)
106#define MEM_DISCARD(sec)
107#else
108#define MEM_KEEP(sec)
109#define MEM_DISCARD(sec) *(.mem##sec)
110#endif
111
112#ifdef CONFIG_FTRACE_MCOUNT_RECORD
113#ifdef CC_USING_PATCHABLE_FUNCTION_ENTRY
114#define MCOUNT_REC() . = ALIGN(8); \
115 __start_mcount_loc = .; \
116 KEEP(*(__patchable_function_entries)) \
117 __stop_mcount_loc = .;
118#else
119#define MCOUNT_REC() . = ALIGN(8); \
120 __start_mcount_loc = .; \
121 KEEP(*(__mcount_loc)) \
122 __stop_mcount_loc = .;
123#endif
124#else
125#define MCOUNT_REC()
126#endif
127
128#ifdef CONFIG_TRACE_BRANCH_PROFILING
129#define LIKELY_PROFILE() __start_annotated_branch_profile = .; \
130 KEEP(*(_ftrace_annotated_branch)) \
131 __stop_annotated_branch_profile = .;
132#else
133#define LIKELY_PROFILE()
134#endif
135
136#ifdef CONFIG_PROFILE_ALL_BRANCHES
137#define BRANCH_PROFILE() __start_branch_profile = .; \
138 KEEP(*(_ftrace_branch)) \
139 __stop_branch_profile = .;
140#else
141#define BRANCH_PROFILE()
142#endif
143
144#ifdef CONFIG_KPROBES
145#define KPROBE_BLACKLIST() . = ALIGN(8); \
146 __start_kprobe_blacklist = .; \
147 KEEP(*(_kprobe_blacklist)) \
148 __stop_kprobe_blacklist = .;
149#else
150#define KPROBE_BLACKLIST()
151#endif
152
153#ifdef CONFIG_FUNCTION_ERROR_INJECTION
154#define ERROR_INJECT_WHITELIST() STRUCT_ALIGN(); \
155 __start_error_injection_whitelist = .; \
156 KEEP(*(_error_injection_whitelist)) \
157 __stop_error_injection_whitelist = .;
158#else
159#define ERROR_INJECT_WHITELIST()
160#endif
161
162#ifdef CONFIG_EVENT_TRACING
163#define FTRACE_EVENTS() . = ALIGN(8); \
164 __start_ftrace_events = .; \
165 KEEP(*(_ftrace_events)) \
166 __stop_ftrace_events = .; \
167 __start_ftrace_eval_maps = .; \
168 KEEP(*(_ftrace_eval_map)) \
169 __stop_ftrace_eval_maps = .;
170#else
171#define FTRACE_EVENTS()
172#endif
173
174#ifdef CONFIG_TRACING
175#define TRACE_PRINTKS() __start___trace_bprintk_fmt = .; \
176 KEEP(*(__trace_printk_fmt)) \
177 __stop___trace_bprintk_fmt = .;
178#define TRACEPOINT_STR() __start___tracepoint_str = .; \
179 KEEP(*(__tracepoint_str)) \
180 __stop___tracepoint_str = .;
181#else
182#define TRACE_PRINTKS()
183#define TRACEPOINT_STR()
184#endif
185
186#ifdef CONFIG_FTRACE_SYSCALLS
187#define TRACE_SYSCALLS() . = ALIGN(8); \
188 __start_syscalls_metadata = .; \
189 KEEP(*(__syscalls_metadata)) \
190 __stop_syscalls_metadata = .;
191#else
192#define TRACE_SYSCALLS()
193#endif
194
195#ifdef CONFIG_BPF_EVENTS
196#define BPF_RAW_TP() STRUCT_ALIGN(); \
197 __start__bpf_raw_tp = .; \
198 KEEP(*(__bpf_raw_tp_map)) \
199 __stop__bpf_raw_tp = .;
200#else
201#define BPF_RAW_TP()
202#endif
203
204#ifdef CONFIG_SERIAL_EARLYCON
205#define EARLYCON_TABLE() . = ALIGN(8); \
206 __earlycon_table = .; \
207 KEEP(*(__earlycon_table)) \
208 __earlycon_table_end = .;
209#else
210#define EARLYCON_TABLE()
211#endif
212
213#ifdef CONFIG_SECURITY
214#define LSM_TABLE() . = ALIGN(8); \
215 __start_lsm_info = .; \
216 KEEP(*(.lsm_info.init)) \
217 __end_lsm_info = .;
218#else
219#define LSM_TABLE()
220#endif
221
222#define ___OF_TABLE(cfg, name) _OF_TABLE_##cfg(name)
223#define __OF_TABLE(cfg, name) ___OF_TABLE(cfg, name)
224#define OF_TABLE(cfg, name) __OF_TABLE(IS_ENABLED(cfg), name)
225#define _OF_TABLE_0(name)
226#define _OF_TABLE_1(name) \
227 . = ALIGN(8); \
228 __##name##_of_table = .; \
229 KEEP(*(__##name##_of_table)) \
230 KEEP(*(__##name##_of_table_end))
231
232#define TIMER_OF_TABLES() OF_TABLE(CONFIG_TIMER_OF, timer)
233#define IRQCHIP_OF_MATCH_TABLE() OF_TABLE(CONFIG_IRQCHIP, irqchip)
234#define CLK_OF_TABLES() OF_TABLE(CONFIG_COMMON_CLK, clk)
235#define RESERVEDMEM_OF_TABLES() OF_TABLE(CONFIG_OF_RESERVED_MEM, reservedmem)
236#define CPU_METHOD_OF_TABLES() OF_TABLE(CONFIG_SMP, cpu_method)
237#define CPUIDLE_METHOD_OF_TABLES() OF_TABLE(CONFIG_CPU_IDLE, cpuidle_method)
238
239#ifdef CONFIG_ACPI
240#define ACPI_PROBE_TABLE(name) \
241 . = ALIGN(8); \
242 __##name##_acpi_probe_table = .; \
243 KEEP(*(__##name##_acpi_probe_table)) \
244 __##name##_acpi_probe_table_end = .;
245#else
246#define ACPI_PROBE_TABLE(name)
247#endif
248
249#ifdef CONFIG_THERMAL
250#define THERMAL_TABLE(name) \
251 . = ALIGN(8); \
252 __##name##_thermal_table = .; \
253 KEEP(*(__##name##_thermal_table)) \
254 __##name##_thermal_table_end = .;
255#else
256#define THERMAL_TABLE(name)
257#endif
258
259#define KERNEL_DTB() \
260 STRUCT_ALIGN(); \
261 __dtb_start = .; \
262 KEEP(*(.dtb.init.rodata)) \
263 __dtb_end = .;
264
265
266
267
268#define DATA_DATA \
269 *(.xiptext) \
270 *(DATA_MAIN) \
271 *(.ref.data) \
272 *(.data..shared_aligned) \
273 MEM_KEEP(init.data*) \
274 MEM_KEEP(exit.data*) \
275 *(.data.unlikely) \
276 __start_once = .; \
277 *(.data.once) \
278 __end_once = .; \
279 STRUCT_ALIGN(); \
280 *(__tracepoints) \
281 \
282 . = ALIGN(8); \
283 __start___verbose = .; \
284 KEEP(*(__verbose)) \
285 __stop___verbose = .; \
286 LIKELY_PROFILE() \
287 BRANCH_PROFILE() \
288 TRACE_PRINTKS() \
289 BPF_RAW_TP() \
290 TRACEPOINT_STR()
291
292
293
294
295#define NOSAVE_DATA \
296 . = ALIGN(PAGE_SIZE); \
297 __nosave_begin = .; \
298 *(.data..nosave) \
299 . = ALIGN(PAGE_SIZE); \
300 __nosave_end = .;
301
302#define PAGE_ALIGNED_DATA(page_align) \
303 . = ALIGN(page_align); \
304 *(.data..page_aligned)
305
306#define READ_MOSTLY_DATA(align) \
307 . = ALIGN(align); \
308 *(.data..read_mostly) \
309 . = ALIGN(align);
310
311#define CACHELINE_ALIGNED_DATA(align) \
312 . = ALIGN(align); \
313 *(.data..cacheline_aligned)
314
315#define INIT_TASK_DATA(align) \
316 . = ALIGN(align); \
317 __start_init_task = .; \
318 init_thread_union = .; \
319 init_stack = .; \
320 KEEP(*(.data..init_task)) \
321 KEEP(*(.data..init_thread_info)) \
322 . = __start_init_task + THREAD_SIZE; \
323 __end_init_task = .;
324
325#define JUMP_TABLE_DATA \
326 . = ALIGN(8); \
327 __start___jump_table = .; \
328 KEEP(*(__jump_table)) \
329 __stop___jump_table = .;
330
331
332
333
334
335#ifndef RO_AFTER_INIT_DATA
336#define RO_AFTER_INIT_DATA \
337 __start_ro_after_init = .; \
338 *(.data..ro_after_init) \
339 JUMP_TABLE_DATA \
340 __end_ro_after_init = .;
341#endif
342
343
344
345
346#define RO_DATA_SECTION(align) \
347 . = ALIGN((align)); \
348 .rodata : AT(ADDR(.rodata) - LOAD_OFFSET) { \
349 __start_rodata = .; \
350 *(.rodata) *(.rodata.*) \
351 RO_AFTER_INIT_DATA \
352 . = ALIGN(8); \
353 __start___tracepoints_ptrs = .; \
354 KEEP(*(__tracepoints_ptrs)) \
355 __stop___tracepoints_ptrs = .; \
356 *(__tracepoints_strings) \
357 } \
358 \
359 .rodata1 : AT(ADDR(.rodata1) - LOAD_OFFSET) { \
360 *(.rodata1) \
361 } \
362 \
363 \
364 .pci_fixup : AT(ADDR(.pci_fixup) - LOAD_OFFSET) { \
365 __start_pci_fixups_early = .; \
366 KEEP(*(.pci_fixup_early)) \
367 __end_pci_fixups_early = .; \
368 __start_pci_fixups_header = .; \
369 KEEP(*(.pci_fixup_header)) \
370 __end_pci_fixups_header = .; \
371 __start_pci_fixups_final = .; \
372 KEEP(*(.pci_fixup_final)) \
373 __end_pci_fixups_final = .; \
374 __start_pci_fixups_enable = .; \
375 KEEP(*(.pci_fixup_enable)) \
376 __end_pci_fixups_enable = .; \
377 __start_pci_fixups_resume = .; \
378 KEEP(*(.pci_fixup_resume)) \
379 __end_pci_fixups_resume = .; \
380 __start_pci_fixups_resume_early = .; \
381 KEEP(*(.pci_fixup_resume_early)) \
382 __end_pci_fixups_resume_early = .; \
383 __start_pci_fixups_suspend = .; \
384 KEEP(*(.pci_fixup_suspend)) \
385 __end_pci_fixups_suspend = .; \
386 __start_pci_fixups_suspend_late = .; \
387 KEEP(*(.pci_fixup_suspend_late)) \
388 __end_pci_fixups_suspend_late = .; \
389 } \
390 \
391 \
392 .builtin_fw : AT(ADDR(.builtin_fw) - LOAD_OFFSET) { \
393 __start_builtin_fw = .; \
394 KEEP(*(.builtin_fw)) \
395 __end_builtin_fw = .; \
396 } \
397 \
398 TRACEDATA \
399 \
400 \
401 __ksymtab : AT(ADDR(__ksymtab) - LOAD_OFFSET) { \
402 __start___ksymtab = .; \
403 KEEP(*(SORT(___ksymtab+*))) \
404 __stop___ksymtab = .; \
405 } \
406 \
407 \
408 __ksymtab_gpl : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) { \
409 __start___ksymtab_gpl = .; \
410 KEEP(*(SORT(___ksymtab_gpl+*))) \
411 __stop___ksymtab_gpl = .; \
412 } \
413 \
414 \
415 __ksymtab_unused : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) { \
416 __start___ksymtab_unused = .; \
417 KEEP(*(SORT(___ksymtab_unused+*))) \
418 __stop___ksymtab_unused = .; \
419 } \
420 \
421 \
422 __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \
423 __start___ksymtab_unused_gpl = .; \
424 KEEP(*(SORT(___ksymtab_unused_gpl+*))) \
425 __stop___ksymtab_unused_gpl = .; \
426 } \
427 \
428 \
429 __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \
430 __start___ksymtab_gpl_future = .; \
431 KEEP(*(SORT(___ksymtab_gpl_future+*))) \
432 __stop___ksymtab_gpl_future = .; \
433 } \
434 \
435 \
436 __kcrctab : AT(ADDR(__kcrctab) - LOAD_OFFSET) { \
437 __start___kcrctab = .; \
438 KEEP(*(SORT(___kcrctab+*))) \
439 __stop___kcrctab = .; \
440 } \
441 \
442 \
443 __kcrctab_gpl : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) { \
444 __start___kcrctab_gpl = .; \
445 KEEP(*(SORT(___kcrctab_gpl+*))) \
446 __stop___kcrctab_gpl = .; \
447 } \
448 \
449 \
450 __kcrctab_unused : AT(ADDR(__kcrctab_unused) - LOAD_OFFSET) { \
451 __start___kcrctab_unused = .; \
452 KEEP(*(SORT(___kcrctab_unused+*))) \
453 __stop___kcrctab_unused = .; \
454 } \
455 \
456 \
457 __kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \
458 __start___kcrctab_unused_gpl = .; \
459 KEEP(*(SORT(___kcrctab_unused_gpl+*))) \
460 __stop___kcrctab_unused_gpl = .; \
461 } \
462 \
463 \
464 __kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \
465 __start___kcrctab_gpl_future = .; \
466 KEEP(*(SORT(___kcrctab_gpl_future+*))) \
467 __stop___kcrctab_gpl_future = .; \
468 } \
469 \
470 \
471 __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) { \
472 *(__ksymtab_strings) \
473 } \
474 \
475 \
476 __init_rodata : AT(ADDR(__init_rodata) - LOAD_OFFSET) { \
477 *(.ref.rodata) \
478 MEM_KEEP(init.rodata) \
479 MEM_KEEP(exit.rodata) \
480 } \
481 \
482 \
483 __param : AT(ADDR(__param) - LOAD_OFFSET) { \
484 __start___param = .; \
485 KEEP(*(__param)) \
486 __stop___param = .; \
487 } \
488 \
489 \
490 __modver : AT(ADDR(__modver) - LOAD_OFFSET) { \
491 __start___modver = .; \
492 KEEP(*(__modver)) \
493 __stop___modver = .; \
494 . = ALIGN((align)); \
495 __end_rodata = .; \
496 } \
497 . = ALIGN((align));
498
499
500
501#define RODATA RO_DATA_SECTION(4096)
502#define RO_DATA(align) RO_DATA_SECTION(align)
503
504
505
506
507
508
509
510
511
512#define TEXT_TEXT \
513 ALIGN_FUNCTION(); \
514 *(.text.hot TEXT_MAIN .text.fixup .text.unlikely) \
515 *(.text..refcount) \
516 *(.ref.text) \
517 MEM_KEEP(init.text*) \
518 MEM_KEEP(exit.text*) \
519
520
521
522
523#define SCHED_TEXT \
524 ALIGN_FUNCTION(); \
525 __sched_text_start = .; \
526 *(.sched.text) \
527 __sched_text_end = .;
528
529
530
531#define LOCK_TEXT \
532 ALIGN_FUNCTION(); \
533 __lock_text_start = .; \
534 *(.spinlock.text) \
535 __lock_text_end = .;
536
537#define CPUIDLE_TEXT \
538 ALIGN_FUNCTION(); \
539 __cpuidle_text_start = .; \
540 *(.cpuidle.text) \
541 __cpuidle_text_end = .;
542
543#define KPROBES_TEXT \
544 ALIGN_FUNCTION(); \
545 __kprobes_text_start = .; \
546 *(.kprobes.text) \
547 __kprobes_text_end = .;
548
549#define ENTRY_TEXT \
550 ALIGN_FUNCTION(); \
551 __entry_text_start = .; \
552 *(.entry.text) \
553 __entry_text_end = .;
554
555#define IRQENTRY_TEXT \
556 ALIGN_FUNCTION(); \
557 __irqentry_text_start = .; \
558 *(.irqentry.text) \
559 __irqentry_text_end = .;
560
561#define SOFTIRQENTRY_TEXT \
562 ALIGN_FUNCTION(); \
563 __softirqentry_text_start = .; \
564 *(.softirqentry.text) \
565 __softirqentry_text_end = .;
566
567
568#define HEAD_TEXT KEEP(*(.head.text))
569
570#define HEAD_TEXT_SECTION \
571 .head.text : AT(ADDR(.head.text) - LOAD_OFFSET) { \
572 HEAD_TEXT \
573 }
574
575
576
577
578#define EXCEPTION_TABLE(align) \
579 . = ALIGN(align); \
580 __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) { \
581 __start___ex_table = .; \
582 KEEP(*(__ex_table)) \
583 __stop___ex_table = .; \
584 }
585
586
587
588
589#define INIT_TASK_DATA_SECTION(align) \
590 . = ALIGN(align); \
591 .data..init_task : AT(ADDR(.data..init_task) - LOAD_OFFSET) { \
592 INIT_TASK_DATA(align) \
593 }
594
595#ifdef CONFIG_CONSTRUCTORS
596#define KERNEL_CTORS() . = ALIGN(8); \
597 __ctors_start = .; \
598 KEEP(*(.ctors)) \
599 KEEP(*(SORT(.init_array.*))) \
600 KEEP(*(.init_array)) \
601 __ctors_end = .;
602#else
603#define KERNEL_CTORS()
604#endif
605
606
607#define INIT_DATA \
608 KEEP(*(SORT(___kentry+*))) \
609 *(.init.data init.data.*) \
610 MEM_DISCARD(init.data*) \
611 KERNEL_CTORS() \
612 MCOUNT_REC() \
613 *(.init.rodata .init.rodata.*) \
614 FTRACE_EVENTS() \
615 TRACE_SYSCALLS() \
616 KPROBE_BLACKLIST() \
617 ERROR_INJECT_WHITELIST() \
618 MEM_DISCARD(init.rodata) \
619 CLK_OF_TABLES() \
620 RESERVEDMEM_OF_TABLES() \
621 TIMER_OF_TABLES() \
622 CPU_METHOD_OF_TABLES() \
623 CPUIDLE_METHOD_OF_TABLES() \
624 KERNEL_DTB() \
625 IRQCHIP_OF_MATCH_TABLE() \
626 ACPI_PROBE_TABLE(irqchip) \
627 ACPI_PROBE_TABLE(timer) \
628 THERMAL_TABLE(governor) \
629 EARLYCON_TABLE() \
630 LSM_TABLE()
631
632#define INIT_TEXT \
633 *(.init.text .init.text.*) \
634 *(.text.startup) \
635 MEM_DISCARD(init.text*)
636
637#define EXIT_DATA \
638 *(.exit.data .exit.data.*) \
639 *(.fini_array .fini_array.*) \
640 *(.dtors .dtors.*) \
641 MEM_DISCARD(exit.data*) \
642 MEM_DISCARD(exit.rodata*)
643
644#define EXIT_TEXT \
645 *(.exit.text) \
646 *(.text.exit) \
647 MEM_DISCARD(exit.text)
648
649#define EXIT_CALL \
650 *(.exitcall.exit)
651
652
653
654
655
656#define SBSS(sbss_align) \
657 . = ALIGN(sbss_align); \
658 .sbss : AT(ADDR(.sbss) - LOAD_OFFSET) { \
659 *(.dynsbss) \
660 *(SBSS_MAIN) \
661 *(.scommon) \
662 }
663
664
665
666
667
668#ifndef BSS_FIRST_SECTIONS
669#define BSS_FIRST_SECTIONS
670#endif
671
672#define BSS(bss_align) \
673 . = ALIGN(bss_align); \
674 .bss : AT(ADDR(.bss) - LOAD_OFFSET) { \
675 BSS_FIRST_SECTIONS \
676 *(.bss..page_aligned) \
677 *(.dynbss) \
678 *(BSS_MAIN) \
679 *(COMMON) \
680 }
681
682
683
684
685
686
687#define DWARF_DEBUG \
688 \
689 .debug 0 : { *(.debug) } \
690 .line 0 : { *(.line) } \
691 \
692 .debug_srcinfo 0 : { *(.debug_srcinfo) } \
693 .debug_sfnames 0 : { *(.debug_sfnames) } \
694 \
695 .debug_aranges 0 : { *(.debug_aranges) } \
696 .debug_pubnames 0 : { *(.debug_pubnames) } \
697 \
698 .debug_info 0 : { *(.debug_info \
699 .gnu.linkonce.wi.*) } \
700 .debug_abbrev 0 : { *(.debug_abbrev) } \
701 .debug_line 0 : { *(.debug_line) } \
702 .debug_frame 0 : { *(.debug_frame) } \
703 .debug_str 0 : { *(.debug_str) } \
704 .debug_loc 0 : { *(.debug_loc) } \
705 .debug_macinfo 0 : { *(.debug_macinfo) } \
706 .debug_pubtypes 0 : { *(.debug_pubtypes) } \
707 \
708 .debug_ranges 0 : { *(.debug_ranges) } \
709 \
710 .debug_weaknames 0 : { *(.debug_weaknames) } \
711 .debug_funcnames 0 : { *(.debug_funcnames) } \
712 .debug_typenames 0 : { *(.debug_typenames) } \
713 .debug_varnames 0 : { *(.debug_varnames) } \
714 \
715 .debug_gnu_pubnames 0 : { *(.debug_gnu_pubnames) } \
716 .debug_gnu_pubtypes 0 : { *(.debug_gnu_pubtypes) } \
717 \
718 .debug_types 0 : { *(.debug_types) } \
719 \
720 .debug_macro 0 : { *(.debug_macro) } \
721 .debug_addr 0 : { *(.debug_addr) }
722
723
724#define STABS_DEBUG \
725 .stab 0 : { *(.stab) } \
726 .stabstr 0 : { *(.stabstr) } \
727 .stab.excl 0 : { *(.stab.excl) } \
728 .stab.exclstr 0 : { *(.stab.exclstr) } \
729 .stab.index 0 : { *(.stab.index) } \
730 .stab.indexstr 0 : { *(.stab.indexstr) } \
731 .comment 0 : { *(.comment) }
732
733#ifdef CONFIG_GENERIC_BUG
734#define BUG_TABLE \
735 . = ALIGN(8); \
736 __bug_table : AT(ADDR(__bug_table) - LOAD_OFFSET) { \
737 __start___bug_table = .; \
738 KEEP(*(__bug_table)) \
739 __stop___bug_table = .; \
740 }
741#else
742#define BUG_TABLE
743#endif
744
745#ifdef CONFIG_UNWINDER_ORC
746#define ORC_UNWIND_TABLE \
747 . = ALIGN(4); \
748 .orc_unwind_ip : AT(ADDR(.orc_unwind_ip) - LOAD_OFFSET) { \
749 __start_orc_unwind_ip = .; \
750 KEEP(*(.orc_unwind_ip)) \
751 __stop_orc_unwind_ip = .; \
752 } \
753 . = ALIGN(2); \
754 .orc_unwind : AT(ADDR(.orc_unwind) - LOAD_OFFSET) { \
755 __start_orc_unwind = .; \
756 KEEP(*(.orc_unwind)) \
757 __stop_orc_unwind = .; \
758 } \
759 . = ALIGN(4); \
760 .orc_lookup : AT(ADDR(.orc_lookup) - LOAD_OFFSET) { \
761 orc_lookup = .; \
762 . += (((SIZEOF(.text) + LOOKUP_BLOCK_SIZE - 1) / \
763 LOOKUP_BLOCK_SIZE) + 1) * 4; \
764 orc_lookup_end = .; \
765 }
766#else
767#define ORC_UNWIND_TABLE
768#endif
769
770#ifdef CONFIG_PM_TRACE
771#define TRACEDATA \
772 . = ALIGN(4); \
773 .tracedata : AT(ADDR(.tracedata) - LOAD_OFFSET) { \
774 __tracedata_start = .; \
775 KEEP(*(.tracedata)) \
776 __tracedata_end = .; \
777 }
778#else
779#define TRACEDATA
780#endif
781
782#define NOTES \
783 .notes : AT(ADDR(.notes) - LOAD_OFFSET) { \
784 __start_notes = .; \
785 KEEP(*(.note.*)) \
786 __stop_notes = .; \
787 }
788
789#define INIT_SETUP(initsetup_align) \
790 . = ALIGN(initsetup_align); \
791 __setup_start = .; \
792 KEEP(*(.init.setup)) \
793 __setup_end = .;
794
795#define INIT_CALLS_LEVEL(level) \
796 __initcall##level##_start = .; \
797 KEEP(*(.initcall##level##.init)) \
798 KEEP(*(.initcall##level##s.init)) \
799
800#define INIT_CALLS \
801 __initcall_start = .; \
802 KEEP(*(.initcallearly.init)) \
803 INIT_CALLS_LEVEL(0) \
804 INIT_CALLS_LEVEL(1) \
805 INIT_CALLS_LEVEL(2) \
806 INIT_CALLS_LEVEL(3) \
807 INIT_CALLS_LEVEL(4) \
808 INIT_CALLS_LEVEL(5) \
809 INIT_CALLS_LEVEL(rootfs) \
810 INIT_CALLS_LEVEL(6) \
811 INIT_CALLS_LEVEL(7) \
812 __initcall_end = .;
813
814#define CON_INITCALL \
815 __con_initcall_start = .; \
816 KEEP(*(.con_initcall.init)) \
817 __con_initcall_end = .;
818
819#ifdef CONFIG_BLK_DEV_INITRD
820#define INIT_RAM_FS \
821 . = ALIGN(4); \
822 __initramfs_start = .; \
823 KEEP(*(.init.ramfs)) \
824 . = ALIGN(8); \
825 KEEP(*(.init.ramfs.info))
826#else
827#define INIT_RAM_FS
828#endif
829
830
831
832
833
834
835
836
837
838#ifdef CONFIG_AMD_MEM_ENCRYPT
839#define PERCPU_DECRYPTED_SECTION \
840 . = ALIGN(PAGE_SIZE); \
841 *(.data..percpu..decrypted) \
842 . = ALIGN(PAGE_SIZE);
843#else
844#define PERCPU_DECRYPTED_SECTION
845#endif
846
847
848
849
850
851
852
853
854
855
856
857#define DISCARDS \
858 /DISCARD/ : { \
859 EXIT_TEXT \
860 EXIT_DATA \
861 EXIT_CALL \
862 *(.discard) \
863 *(.discard.*) \
864 *(.modinfo) \
865 }
866
867
868
869
870
871
872
873
874
875
876
877#define PERCPU_INPUT(cacheline) \
878 __per_cpu_start = .; \
879 *(.data..percpu..first) \
880 . = ALIGN(PAGE_SIZE); \
881 *(.data..percpu..page_aligned) \
882 . = ALIGN(cacheline); \
883 *(.data..percpu..read_mostly) \
884 . = ALIGN(cacheline); \
885 *(.data..percpu) \
886 *(.data..percpu..shared_aligned) \
887 PERCPU_DECRYPTED_SECTION \
888 __per_cpu_end = .;
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914#define PERCPU_VADDR(cacheline, vaddr, phdr) \
915 __per_cpu_load = .; \
916 .data..percpu vaddr : AT(__per_cpu_load - LOAD_OFFSET) { \
917 PERCPU_INPUT(cacheline) \
918 } phdr \
919 . = __per_cpu_load + SIZEOF(.data..percpu);
920
921
922
923
924
925
926
927
928
929
930
931
932
933#define PERCPU_SECTION(cacheline) \
934 . = ALIGN(PAGE_SIZE); \
935 .data..percpu : AT(ADDR(.data..percpu) - LOAD_OFFSET) { \
936 __per_cpu_load = .; \
937 PERCPU_INPUT(cacheline) \
938 }
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959#define RW_DATA_SECTION(cacheline, pagealigned, inittask) \
960 . = ALIGN(PAGE_SIZE); \
961 .data : AT(ADDR(.data) - LOAD_OFFSET) { \
962 INIT_TASK_DATA(inittask) \
963 NOSAVE_DATA \
964 PAGE_ALIGNED_DATA(pagealigned) \
965 CACHELINE_ALIGNED_DATA(cacheline) \
966 READ_MOSTLY_DATA(cacheline) \
967 DATA_DATA \
968 CONSTRUCTORS \
969 } \
970 BUG_TABLE \
971
972#define INIT_TEXT_SECTION(inittext_align) \
973 . = ALIGN(inittext_align); \
974 .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) { \
975 _sinittext = .; \
976 INIT_TEXT \
977 _einittext = .; \
978 }
979
980#define INIT_DATA_SECTION(initsetup_align) \
981 .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) { \
982 INIT_DATA \
983 INIT_SETUP(initsetup_align) \
984 INIT_CALLS \
985 CON_INITCALL \
986 INIT_RAM_FS \
987 }
988
989#define BSS_SECTION(sbss_align, bss_align, stop_align) \
990 . = ALIGN(sbss_align); \
991 __bss_start = .; \
992 SBSS(sbss_align) \
993 BSS(bss_align) \
994 . = ALIGN(stop_align); \
995 __bss_stop = .;
996