xref: /linux/arch/powerpc/kernel/vmlinux.lds.S (revision ee665ecca6d6775f65b1a4154c34f551f62cec52) 
1#ifdef CONFIG_PPC64
2#define PROVIDE32(x)	PROVIDE(__unused__##x)
3#else
4#define PROVIDE32(x)	PROVIDE(x)
5#endif
6#include <asm/page.h>
7#include <asm-generic/vmlinux.lds.h>
8#include <asm/cache.h>
9
10ENTRY(_stext)
11
12PHDRS {
13	kernel PT_LOAD FLAGS(7); /* RWX */
14	notes PT_NOTE FLAGS(0);
15	dummy PT_NOTE FLAGS(0);
16
17	/* binutils < 2.18 has a bug that makes it misbehave when taking an
18	   ELF file with all segments at load address 0 as input.  This
19	   happens when running "strip" on vmlinux, because of the AT() magic
20	   in this linker script.  People using GCC >= 4.2 won't run into
21	   this problem, because the "build-id" support will put some data
22	   into the "notes" segment (at a non-zero load address).
23
24	   To work around this, we force some data into both the "dummy"
25	   segment and the kernel segment, so the dummy segment will get a
26	   non-zero load address.  It's not enough to always create the
27	   "notes" segment, since if nothing gets assigned to it, its load
28	   address will be zero.  */
29}
30
31#ifdef CONFIG_PPC64
32OUTPUT_ARCH(powerpc:common64)
33jiffies = jiffies_64;
34#else
35OUTPUT_ARCH(powerpc:common)
36jiffies = jiffies_64 + 4;
37#endif
38SECTIONS
39{
40	/* Sections to be discarded. */
41	/DISCARD/ : {
42	*(.exitcall.exit)
43	EXIT_DATA
44	}
45
46	. = KERNELBASE;
47
48/*
49 * Text, read only data and other permanent read-only sections
50 */
51
52	/* Text and gots */
53	.text : AT(ADDR(.text) - LOAD_OFFSET) {
54		ALIGN_FUNCTION();
55		*(.text.head)
56		_text = .;
57		*(.text .fixup .text.init.refok .exit.text.refok __ftr_alt_*)
58		SCHED_TEXT
59		LOCK_TEXT
60		KPROBES_TEXT
61
62#ifdef CONFIG_PPC32
63		*(.got1)
64		__got2_start = .;
65		*(.got2)
66		__got2_end = .;
67#endif /* CONFIG_PPC32 */
68
69	} :kernel
70
71	. = ALIGN(PAGE_SIZE);
72	_etext = .;
73	PROVIDE32 (etext = .);
74
75	/* Read-only data */
76	RODATA
77
78	/* Exception & bug tables */
79	__ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
80		__start___ex_table = .;
81		*(__ex_table)
82		__stop___ex_table = .;
83	}
84
85	NOTES :kernel :notes
86
87	/* The dummy segment contents for the bug workaround mentioned above
88	   near PHDRS.  */
89	.dummy : AT(ADDR(.dummy) - LOAD_OFFSET) {
90		LONG(0)
91		LONG(0)
92		LONG(0)
93	} :kernel :dummy
94
95/*
96 * Init sections discarded at runtime
97 */
98	. = ALIGN(PAGE_SIZE);
99	__init_begin = .;
100
101	.init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
102		_sinittext = .;
103		INIT_TEXT
104		_einittext = .;
105	} :kernel
106
107	/* .exit.text is discarded at runtime, not link time,
108	 * to deal with references from __bug_table
109	 */
110	.exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
111		EXIT_TEXT
112	}
113
114	.init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
115		INIT_DATA
116		__vtop_table_begin = .;
117		*(.vtop_fixup);
118		__vtop_table_end = .;
119		__ptov_table_begin = .;
120		*(.ptov_fixup);
121		__ptov_table_end = .;
122#ifdef CONFIG_PPC_ISERIES
123		__dt_strings_start = .;
124		*(.dt_strings);
125		__dt_strings_end = .;
126#endif
127	}
128
129	. = ALIGN(16);
130	.init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
131		__setup_start = .;
132		*(.init.setup)
133		__setup_end = .;
134	}
135
136	.initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
137		__initcall_start = .;
138		INITCALLS
139		__initcall_end = .;
140		}
141
142	.con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
143		__con_initcall_start = .;
144		*(.con_initcall.init)
145		__con_initcall_end = .;
146	}
147
148	SECURITY_INIT
149
150	. = ALIGN(8);
151	__ftr_fixup : AT(ADDR(__ftr_fixup) - LOAD_OFFSET) {
152		__start___ftr_fixup = .;
153		*(__ftr_fixup)
154		__stop___ftr_fixup = .;
155	}
156	. = ALIGN(8);
157	__mmu_ftr_fixup : AT(ADDR(__mmu_ftr_fixup) - LOAD_OFFSET) {
158		__start___mmu_ftr_fixup = .;
159		*(__mmu_ftr_fixup)
160		__stop___mmu_ftr_fixup = .;
161	}
162	. = ALIGN(8);
163	__lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
164		__start___lwsync_fixup = .;
165		*(__lwsync_fixup)
166		__stop___lwsync_fixup = .;
167	}
168#ifdef CONFIG_PPC64
169	. = ALIGN(8);
170	__fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
171		__start___fw_ftr_fixup = .;
172		*(__fw_ftr_fixup)
173		__stop___fw_ftr_fixup = .;
174	}
175#endif
176#ifdef CONFIG_BLK_DEV_INITRD
177	. = ALIGN(PAGE_SIZE);
178	.init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
179		__initramfs_start = .;
180		*(.init.ramfs)
181		__initramfs_end = .;
182	}
183#endif
184	PERCPU(PAGE_SIZE)
185
186	. = ALIGN(8);
187	.machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
188		__machine_desc_start = . ;
189		*(.machine.desc)
190		__machine_desc_end = . ;
191	}
192#ifdef CONFIG_RELOCATABLE
193	. = ALIGN(8);
194	.dynsym : AT(ADDR(.dynsym) - LOAD_OFFSET) { *(.dynsym) }
195	.dynstr : AT(ADDR(.dynstr) - LOAD_OFFSET) { *(.dynstr) }
196	.dynamic : AT(ADDR(.dynamic) - LOAD_OFFSET)
197	{
198		__dynamic_start = .;
199		*(.dynamic)
200	}
201	.hash : AT(ADDR(.hash) - LOAD_OFFSET) { *(.hash) }
202	.interp : AT(ADDR(.interp) - LOAD_OFFSET) { *(.interp) }
203	.rela.dyn : AT(ADDR(.rela.dyn) - LOAD_OFFSET)
204	{
205		__rela_dyn_start = .;
206		*(.rela*)
207	}
208#endif
209
210	/* freed after init ends here */
211	. = ALIGN(PAGE_SIZE);
212	__init_end = .;
213
214/*
215 * And now the various read/write data
216 */
217
218	. = ALIGN(PAGE_SIZE);
219	_sdata = .;
220
221#ifdef CONFIG_PPC32
222	.data : AT(ADDR(.data) - LOAD_OFFSET) {
223		DATA_DATA
224		*(.sdata)
225		*(.got.plt) *(.got)
226	}
227#else
228	.data : AT(ADDR(.data) - LOAD_OFFSET) {
229		DATA_DATA
230		*(.data.rel*)
231		*(.toc1)
232		*(.branch_lt)
233	}
234
235	.opd : AT(ADDR(.opd) - LOAD_OFFSET) {
236		*(.opd)
237	}
238
239	.got : AT(ADDR(.got) - LOAD_OFFSET) {
240		__toc_start = .;
241		*(.got)
242		*(.toc)
243	}
244#endif
245
246	. = ALIGN(PAGE_SIZE);
247	_edata  =  .;
248	PROVIDE32 (edata = .);
249
250	/* The initial task and kernel stack */
251#ifdef CONFIG_PPC32
252	. = ALIGN(8192);
253#else
254	. = ALIGN(16384);
255#endif
256	.data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
257		*(.data.init_task)
258	}
259
260	. = ALIGN(PAGE_SIZE);
261	.data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
262		*(.data.page_aligned)
263	}
264
265	.data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
266		*(.data.cacheline_aligned)
267	}
268
269	. = ALIGN(L1_CACHE_BYTES);
270	.data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
271		*(.data.read_mostly)
272	}
273
274	. = ALIGN(PAGE_SIZE);
275	.data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
276		__nosave_begin = .;
277		*(.data.nosave)
278		. = ALIGN(PAGE_SIZE);
279		__nosave_end = .;
280	}
281
282/*
283 * And finally the bss
284 */
285
286	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {
287		__bss_start = .;
288		*(.sbss) *(.scommon)
289		*(.dynbss)
290		*(.bss)
291		*(COMMON)
292		__bss_stop = .;
293	}
294
295	. = ALIGN(PAGE_SIZE);
296	_end = . ;
297	PROVIDE32 (end = .);
298}
299