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		. = ALIGN(8);						\
336		__start___tracepoints_ptrs = .;				\
337		KEEP(*(__tracepoints_ptrs)) /* Tracepoints: pointer array */ \
338		__stop___tracepoints_ptrs = .;				\
339		*(__tracepoints_strings)/* Tracepoints: strings */	\
340	}								\
341									\
342	.rodata1          : AT(ADDR(.rodata1) - LOAD_OFFSET) {		\
343		*(.rodata1)						\
344	}								\
345									\
346	/* PCI quirks */						\
347	.pci_fixup        : AT(ADDR(.pci_fixup) - LOAD_OFFSET) {	\
348		__start_pci_fixups_early = .;				\
349		KEEP(*(.pci_fixup_early))				\
350		__end_pci_fixups_early = .;				\
351		__start_pci_fixups_header = .;				\
352		KEEP(*(.pci_fixup_header))				\
353		__end_pci_fixups_header = .;				\
354		__start_pci_fixups_final = .;				\
355		KEEP(*(.pci_fixup_final))				\
356		__end_pci_fixups_final = .;				\
357		__start_pci_fixups_enable = .;				\
358		KEEP(*(.pci_fixup_enable))				\
359		__end_pci_fixups_enable = .;				\
360		__start_pci_fixups_resume = .;				\
361		KEEP(*(.pci_fixup_resume))				\
362		__end_pci_fixups_resume = .;				\
363		__start_pci_fixups_resume_early = .;			\
364		KEEP(*(.pci_fixup_resume_early))			\
365		__end_pci_fixups_resume_early = .;			\
366		__start_pci_fixups_suspend = .;				\
367		KEEP(*(.pci_fixup_suspend))				\
368		__end_pci_fixups_suspend = .;				\
369		__start_pci_fixups_suspend_late = .;			\
370		KEEP(*(.pci_fixup_suspend_late))			\
371		__end_pci_fixups_suspend_late = .;			\
372	}								\
373									\
374	/* Built-in firmware blobs */					\
375	.builtin_fw        : AT(ADDR(.builtin_fw) - LOAD_OFFSET) {	\
376		__start_builtin_fw = .;					\
377		KEEP(*(.builtin_fw))					\
378		__end_builtin_fw = .;					\
379	}								\
380									\
381	TRACEDATA							\
382									\
383	/* Kernel symbol table: Normal symbols */			\
384	__ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {		\
385		__start___ksymtab = .;					\
386		KEEP(*(SORT(___ksymtab+*)))				\
387		__stop___ksymtab = .;					\
388	}								\
389									\
390	/* Kernel symbol table: GPL-only symbols */			\
391	__ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {	\
392		__start___ksymtab_gpl = .;				\
393		KEEP(*(SORT(___ksymtab_gpl+*)))				\
394		__stop___ksymtab_gpl = .;				\
395	}								\
396									\
397	/* Kernel symbol table: Normal unused symbols */		\
398	__ksymtab_unused  : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) {	\
399		__start___ksymtab_unused = .;				\
400		KEEP(*(SORT(___ksymtab_unused+*)))			\
401		__stop___ksymtab_unused = .;				\
402	}								\
403									\
404	/* Kernel symbol table: GPL-only unused symbols */		\
405	__ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \
406		__start___ksymtab_unused_gpl = .;			\
407		KEEP(*(SORT(___ksymtab_unused_gpl+*)))			\
408		__stop___ksymtab_unused_gpl = .;			\
409	}								\
410									\
411	/* Kernel symbol table: GPL-future-only symbols */		\
412	__ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \
413		__start___ksymtab_gpl_future = .;			\
414		KEEP(*(SORT(___ksymtab_gpl_future+*)))			\
415		__stop___ksymtab_gpl_future = .;			\
416	}								\
417									\
418	/* Kernel symbol table: Normal symbols */			\
419	__kcrctab         : AT(ADDR(__kcrctab) - LOAD_OFFSET) {		\
420		__start___kcrctab = .;					\
421		KEEP(*(SORT(___kcrctab+*)))				\
422		__stop___kcrctab = .;					\
423	}								\
424									\
425	/* Kernel symbol table: GPL-only symbols */			\
426	__kcrctab_gpl     : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) {	\
427		__start___kcrctab_gpl = .;				\
428		KEEP(*(SORT(___kcrctab_gpl+*)))				\
429		__stop___kcrctab_gpl = .;				\
430	}								\
431									\
432	/* Kernel symbol table: Normal unused symbols */		\
433	__kcrctab_unused  : AT(ADDR(__kcrctab_unused) - LOAD_OFFSET) {	\
434		__start___kcrctab_unused = .;				\
435		KEEP(*(SORT(___kcrctab_unused+*)))			\
436		__stop___kcrctab_unused = .;				\
437	}								\
438									\
439	/* Kernel symbol table: GPL-only unused symbols */		\
440	__kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \
441		__start___kcrctab_unused_gpl = .;			\
442		KEEP(*(SORT(___kcrctab_unused_gpl+*)))			\
443		__stop___kcrctab_unused_gpl = .;			\
444	}								\
445									\
446	/* Kernel symbol table: GPL-future-only symbols */		\
447	__kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \
448		__start___kcrctab_gpl_future = .;			\
449		KEEP(*(SORT(___kcrctab_gpl_future+*)))			\
450		__stop___kcrctab_gpl_future = .;			\
451	}								\
452									\
453	/* Kernel symbol table: strings */				\
454        __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) {	\
455		*(__ksymtab_strings)					\
456	}								\
457									\
458	/* __*init sections */						\
459	__init_rodata : AT(ADDR(__init_rodata) - LOAD_OFFSET) {		\
460		*(.ref.rodata)						\
461		MEM_KEEP(init.rodata)					\
462		MEM_KEEP(exit.rodata)					\
463	}								\
464									\
465	/* Built-in module parameters. */				\
466	__param : AT(ADDR(__param) - LOAD_OFFSET) {			\
467		__start___param = .;					\
468		KEEP(*(__param))					\
469		__stop___param = .;					\
470	}								\
471									\
472	/* Built-in module versions. */					\
473	__modver : AT(ADDR(__modver) - LOAD_OFFSET) {			\
474		__start___modver = .;					\
475		KEEP(*(__modver))					\
476		__stop___modver = .;					\
477		. = ALIGN((align));					\
478		__end_rodata = .;					\
479	}								\
480	. = ALIGN((align));
481
482/* RODATA & RO_DATA provided for backward compatibility.
483 * All archs are supposed to use RO_DATA() */
484#define RODATA          RO_DATA_SECTION(4096)
485#define RO_DATA(align)  RO_DATA_SECTION(align)
486
487/*
488 * .text section. Map to function alignment to avoid address changes
489 * during second ld run in second ld pass when generating System.map
490 *
491 * TEXT_MAIN here will match .text.fixup and .text.unlikely if dead
492 * code elimination is enabled, so these sections should be converted
493 * to use ".." first.
494 */
495#define TEXT_TEXT							\
496		ALIGN_FUNCTION();					\
497		*(.text.hot TEXT_MAIN .text.fixup .text.unlikely)	\
498		*(.text..refcount)					\
499		*(.ref.text)						\
500	MEM_KEEP(init.text*)						\
501	MEM_KEEP(exit.text*)						\
502
503
504/* sched.text is aling to function alignment to secure we have same
505 * address even at second ld pass when generating System.map */
506#define SCHED_TEXT							\
507		ALIGN_FUNCTION();					\
508		__sched_text_start = .;					\
509		*(.sched.text)						\
510		__sched_text_end = .;
511
512/* spinlock.text is aling to function alignment to secure we have same
513 * address even at second ld pass when generating System.map */
514#define LOCK_TEXT							\
515		ALIGN_FUNCTION();					\
516		__lock_text_start = .;					\
517		*(.spinlock.text)					\
518		__lock_text_end = .;
519
520#define CPUIDLE_TEXT							\
521		ALIGN_FUNCTION();					\
522		__cpuidle_text_start = .;				\
523		*(.cpuidle.text)					\
524		__cpuidle_text_end = .;
525
526#define KPROBES_TEXT							\
527		ALIGN_FUNCTION();					\
528		__kprobes_text_start = .;				\
529		*(.kprobes.text)					\
530		__kprobes_text_end = .;
531
532#define ENTRY_TEXT							\
533		ALIGN_FUNCTION();					\
534		__entry_text_start = .;					\
535		*(.entry.text)						\
536		__entry_text_end = .;
537
538#define IRQENTRY_TEXT							\
539		ALIGN_FUNCTION();					\
540		__irqentry_text_start = .;				\
541		*(.irqentry.text)					\
542		__irqentry_text_end = .;
543
544#define SOFTIRQENTRY_TEXT						\
545		ALIGN_FUNCTION();					\
546		__softirqentry_text_start = .;				\
547		*(.softirqentry.text)					\
548		__softirqentry_text_end = .;
549
550/* Section used for early init (in .S files) */
551#define HEAD_TEXT  KEEP(*(.head.text))
552
553#define HEAD_TEXT_SECTION							\
554	.head.text : AT(ADDR(.head.text) - LOAD_OFFSET) {		\
555		HEAD_TEXT						\
556	}
557
558/*
559 * Exception table
560 */
561#define EXCEPTION_TABLE(align)						\
562	. = ALIGN(align);						\
563	__ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {		\
564		__start___ex_table = .;					\
565		KEEP(*(__ex_table))					\
566		__stop___ex_table = .;					\
567	}
568
569/*
570 * Init task
571 */
572#define INIT_TASK_DATA_SECTION(align)					\
573	. = ALIGN(align);						\
574	.data..init_task :  AT(ADDR(.data..init_task) - LOAD_OFFSET) {	\
575		INIT_TASK_DATA(align)					\
576	}
577
578#ifdef CONFIG_CONSTRUCTORS
579#define KERNEL_CTORS()	. = ALIGN(8);			   \
580			__ctors_start = .;		   \
581			KEEP(*(.ctors))			   \
582			KEEP(*(SORT(.init_array.*)))	   \
583			KEEP(*(.init_array))		   \
584			__ctors_end = .;
585#else
586#define KERNEL_CTORS()
587#endif
588
589/* init and exit section handling */
590#define INIT_DATA							\
591	KEEP(*(SORT(___kentry+*)))					\
592	*(.init.data init.data.*)					\
593	MEM_DISCARD(init.data*)						\
594	KERNEL_CTORS()							\
595	MCOUNT_REC()							\
596	*(.init.rodata .init.rodata.*)					\
597	FTRACE_EVENTS()							\
598	TRACE_SYSCALLS()						\
599	KPROBE_BLACKLIST()						\
600	ERROR_INJECT_WHITELIST()					\
601	MEM_DISCARD(init.rodata)					\
602	CLK_OF_TABLES()							\
603	RESERVEDMEM_OF_TABLES()						\
604	TIMER_OF_TABLES()						\
605	CPU_METHOD_OF_TABLES()						\
606	CPUIDLE_METHOD_OF_TABLES()					\
607	KERNEL_DTB()							\
608	IRQCHIP_OF_MATCH_TABLE()					\
609	ACPI_PROBE_TABLE(irqchip)					\
610	ACPI_PROBE_TABLE(timer)						\
611	EARLYCON_TABLE()						\
612	LSM_TABLE()
613
614#define INIT_TEXT							\
615	*(.init.text .init.text.*)					\
616	*(.text.startup)						\
617	MEM_DISCARD(init.text*)
618
619#define EXIT_DATA							\
620	*(.exit.data .exit.data.*)					\
621	*(.fini_array .fini_array.*)					\
622	*(.dtors .dtors.*)						\
623	MEM_DISCARD(exit.data*)						\
624	MEM_DISCARD(exit.rodata*)
625
626#define EXIT_TEXT							\
627	*(.exit.text)							\
628	*(.text.exit)							\
629	MEM_DISCARD(exit.text)
630
631#define EXIT_CALL							\
632	*(.exitcall.exit)
633
634/*
635 * bss (Block Started by Symbol) - uninitialized data
636 * zeroed during startup
637 */
638#define SBSS(sbss_align)						\
639	. = ALIGN(sbss_align);						\
640	.sbss : AT(ADDR(.sbss) - LOAD_OFFSET) {				\
641		*(.dynsbss)						\
642		*(SBSS_MAIN)						\
643		*(.scommon)						\
644	}
645
646/*
647 * Allow archectures to redefine BSS_FIRST_SECTIONS to add extra
648 * sections to the front of bss.
649 */
650#ifndef BSS_FIRST_SECTIONS
651#define BSS_FIRST_SECTIONS
652#endif
653
654#define BSS(bss_align)							\
655	. = ALIGN(bss_align);						\
656	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {				\
657		BSS_FIRST_SECTIONS					\
658		*(.bss..page_aligned)					\
659		*(.dynbss)						\
660		*(BSS_MAIN)						\
661		*(COMMON)						\
662	}
663
664/*
665 * DWARF debug sections.
666 * Symbols in the DWARF debugging sections are relative to
667 * the beginning of the section so we begin them at 0.
668 */
669#define DWARF_DEBUG							\
670		/* DWARF 1 */						\
671		.debug          0 : { *(.debug) }			\
672		.line           0 : { *(.line) }			\
673		/* GNU DWARF 1 extensions */				\
674		.debug_srcinfo  0 : { *(.debug_srcinfo) }		\
675		.debug_sfnames  0 : { *(.debug_sfnames) }		\
676		/* DWARF 1.1 and DWARF 2 */				\
677		.debug_aranges  0 : { *(.debug_aranges) }		\
678		.debug_pubnames 0 : { *(.debug_pubnames) }		\
679		/* DWARF 2 */						\
680		.debug_info     0 : { *(.debug_info			\
681				.gnu.linkonce.wi.*) }			\
682		.debug_abbrev   0 : { *(.debug_abbrev) }		\
683		.debug_line     0 : { *(.debug_line) }			\
684		.debug_frame    0 : { *(.debug_frame) }			\
685		.debug_str      0 : { *(.debug_str) }			\
686		.debug_loc      0 : { *(.debug_loc) }			\
687		.debug_macinfo  0 : { *(.debug_macinfo) }		\
688		.debug_pubtypes 0 : { *(.debug_pubtypes) }		\
689		/* DWARF 3 */						\
690		.debug_ranges	0 : { *(.debug_ranges) }		\
691		/* SGI/MIPS DWARF 2 extensions */			\
692		.debug_weaknames 0 : { *(.debug_weaknames) }		\
693		.debug_funcnames 0 : { *(.debug_funcnames) }		\
694		.debug_typenames 0 : { *(.debug_typenames) }		\
695		.debug_varnames  0 : { *(.debug_varnames) }		\
696		/* GNU DWARF 2 extensions */				\
697		.debug_gnu_pubnames 0 : { *(.debug_gnu_pubnames) }	\
698		.debug_gnu_pubtypes 0 : { *(.debug_gnu_pubtypes) }	\
699		/* DWARF 4 */						\
700		.debug_types	0 : { *(.debug_types) }			\
701		/* DWARF 5 */						\
702		.debug_macro	0 : { *(.debug_macro) }			\
703		.debug_addr	0 : { *(.debug_addr) }
704
705		/* Stabs debugging sections.  */
706#define STABS_DEBUG							\
707		.stab 0 : { *(.stab) }					\
708		.stabstr 0 : { *(.stabstr) }				\
709		.stab.excl 0 : { *(.stab.excl) }			\
710		.stab.exclstr 0 : { *(.stab.exclstr) }			\
711		.stab.index 0 : { *(.stab.index) }			\
712		.stab.indexstr 0 : { *(.stab.indexstr) }		\
713		.comment 0 : { *(.comment) }
714
715#ifdef CONFIG_GENERIC_BUG
716#define BUG_TABLE							\
717	. = ALIGN(8);							\
718	__bug_table : AT(ADDR(__bug_table) - LOAD_OFFSET) {		\
719		__start___bug_table = .;				\
720		KEEP(*(__bug_table))					\
721		__stop___bug_table = .;					\
722	}
723#else
724#define BUG_TABLE
725#endif
726
727#ifdef CONFIG_UNWINDER_ORC
728#define ORC_UNWIND_TABLE						\
729	. = ALIGN(4);							\
730	.orc_unwind_ip : AT(ADDR(.orc_unwind_ip) - LOAD_OFFSET) {	\
731		__start_orc_unwind_ip = .;				\
732		KEEP(*(.orc_unwind_ip))					\
733		__stop_orc_unwind_ip = .;				\
734	}								\
735	. = ALIGN(2);							\
736	.orc_unwind : AT(ADDR(.orc_unwind) - LOAD_OFFSET) {		\
737		__start_orc_unwind = .;					\
738		KEEP(*(.orc_unwind))					\
739		__stop_orc_unwind = .;					\
740	}								\
741	. = ALIGN(4);							\
742	.orc_lookup : AT(ADDR(.orc_lookup) - LOAD_OFFSET) {		\
743		orc_lookup = .;						\
744		. += (((SIZEOF(.text) + LOOKUP_BLOCK_SIZE - 1) /	\
745			LOOKUP_BLOCK_SIZE) + 1) * 4;			\
746		orc_lookup_end = .;					\
747	}
748#else
749#define ORC_UNWIND_TABLE
750#endif
751
752#ifdef CONFIG_PM_TRACE
753#define TRACEDATA							\
754	. = ALIGN(4);							\
755	.tracedata : AT(ADDR(.tracedata) - LOAD_OFFSET) {		\
756		__tracedata_start = .;					\
757		KEEP(*(.tracedata))					\
758		__tracedata_end = .;					\
759	}
760#else
761#define TRACEDATA
762#endif
763
764#define NOTES								\
765	.notes : AT(ADDR(.notes) - LOAD_OFFSET) {			\
766		__start_notes = .;					\
767		KEEP(*(.note.*))					\
768		__stop_notes = .;					\
769	}
770
771#define INIT_SETUP(initsetup_align)					\
772		. = ALIGN(initsetup_align);				\
773		__setup_start = .;					\
774		KEEP(*(.init.setup))					\
775		__setup_end = .;
776
777#define INIT_CALLS_LEVEL(level)						\
778		__initcall##level##_start = .;				\
779		KEEP(*(.initcall##level##.init))			\
780		KEEP(*(.initcall##level##s.init))			\
781
782#define INIT_CALLS							\
783		__initcall_start = .;					\
784		KEEP(*(.initcallearly.init))				\
785		INIT_CALLS_LEVEL(0)					\
786		INIT_CALLS_LEVEL(1)					\
787		INIT_CALLS_LEVEL(2)					\
788		INIT_CALLS_LEVEL(3)					\
789		INIT_CALLS_LEVEL(4)					\
790		INIT_CALLS_LEVEL(5)					\
791		INIT_CALLS_LEVEL(rootfs)				\
792		INIT_CALLS_LEVEL(6)					\
793		INIT_CALLS_LEVEL(7)					\
794		__initcall_end = .;
795
796#define CON_INITCALL							\
797		__con_initcall_start = .;				\
798		KEEP(*(.con_initcall.init))				\
799		__con_initcall_end = .;
800
801#ifdef CONFIG_BLK_DEV_INITRD
802#define INIT_RAM_FS							\
803	. = ALIGN(4);							\
804	__initramfs_start = .;						\
805	KEEP(*(.init.ramfs))						\
806	. = ALIGN(8);							\
807	KEEP(*(.init.ramfs.info))
808#else
809#define INIT_RAM_FS
810#endif
811
812/*
813 * Memory encryption operates on a page basis. Since we need to clear
814 * the memory encryption mask for this section, it needs to be aligned
815 * on a page boundary and be a page-size multiple in length.
816 *
817 * Note: We use a separate section so that only this section gets
818 * decrypted to avoid exposing more than we wish.
819 */
820#ifdef CONFIG_AMD_MEM_ENCRYPT
821#define PERCPU_DECRYPTED_SECTION					\
822	. = ALIGN(PAGE_SIZE);						\
823	*(.data..percpu..decrypted)					\
824	. = ALIGN(PAGE_SIZE);
825#else
826#define PERCPU_DECRYPTED_SECTION
827#endif
828
829
830/*
831 * Default discarded sections.
832 *
833 * Some archs want to discard exit text/data at runtime rather than
834 * link time due to cross-section references such as alt instructions,
835 * bug table, eh_frame, etc.  DISCARDS must be the last of output
836 * section definitions so that such archs put those in earlier section
837 * definitions.
838 */
839#define DISCARDS							\
840	/DISCARD/ : {							\
841	EXIT_TEXT							\
842	EXIT_DATA							\
843	EXIT_CALL							\
844	*(.discard)							\
845	*(.discard.*)							\
846	*(.modinfo)							\
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