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