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(0xf177)
91	} :kernel :dummy
92
93/*
94 * Init sections discarded at runtime
95 */
96	. = ALIGN(PAGE_SIZE);
97	__init_begin = .;
98
99	.init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
100		_sinittext = .;
101		INIT_TEXT
102		_einittext = .;
103	} :kernel
104
105	/* .exit.text is discarded at runtime, not link time,
106	 * to deal with references from __bug_table
107	 */
108	.exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
109		EXIT_TEXT
110	}
111
112	.init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
113		INIT_DATA
114		__vtop_table_begin = .;
115		*(.vtop_fixup);
116		__vtop_table_end = .;
117		__ptov_table_begin = .;
118		*(.ptov_fixup);
119		__ptov_table_end = .;
120#ifdef CONFIG_PPC_ISERIES
121		__dt_strings_start = .;
122		*(.dt_strings);
123		__dt_strings_end = .;
124#endif
125	}
126
127	. = ALIGN(16);
128	.init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
129		__setup_start = .;
130		*(.init.setup)
131		__setup_end = .;
132	}
133
134	.initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
135		__initcall_start = .;
136		INITCALLS
137		__initcall_end = .;
138		}
139
140	.con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
141		__con_initcall_start = .;
142		*(.con_initcall.init)
143		__con_initcall_end = .;
144	}
145
146	SECURITY_INIT
147
148	. = ALIGN(8);
149	__ftr_fixup : AT(ADDR(__ftr_fixup) - LOAD_OFFSET) {
150		__start___ftr_fixup = .;
151		*(__ftr_fixup)
152		__stop___ftr_fixup = .;
153	}
154	. = ALIGN(8);
155	__lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
156		__start___lwsync_fixup = .;
157		*(__lwsync_fixup)
158		__stop___lwsync_fixup = .;
159	}
160#ifdef CONFIG_PPC64
161	. = ALIGN(8);
162	__fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
163		__start___fw_ftr_fixup = .;
164		*(__fw_ftr_fixup)
165		__stop___fw_ftr_fixup = .;
166	}
167#endif
168#ifdef CONFIG_BLK_DEV_INITRD
169	. = ALIGN(PAGE_SIZE);
170	.init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
171		__initramfs_start = .;
172		*(.init.ramfs)
173		__initramfs_end = .;
174	}
175#endif
176	. = ALIGN(PAGE_SIZE);
177	.data.percpu  : AT(ADDR(.data.percpu) - LOAD_OFFSET) {
178		__per_cpu_start = .;
179		*(.data.percpu)
180		*(.data.percpu.shared_aligned)
181		__per_cpu_end = .;
182	}
183
184	. = ALIGN(8);
185	.machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
186		__machine_desc_start = . ;
187		*(.machine.desc)
188		__machine_desc_end = . ;
189	}
190#ifdef CONFIG_RELOCATABLE
191	. = ALIGN(8);
192	.dynsym : AT(ADDR(.dynsym) - LOAD_OFFSET) { *(.dynsym) }
193	.dynstr : AT(ADDR(.dynstr) - LOAD_OFFSET) { *(.dynstr) }
194	.dynamic : AT(ADDR(.dynamic) - LOAD_OFFSET)
195	{
196		__dynamic_start = .;
197		*(.dynamic)
198	}
199	.hash : AT(ADDR(.hash) - LOAD_OFFSET) { *(.hash) }
200	.interp : AT(ADDR(.interp) - LOAD_OFFSET) { *(.interp) }
201	.rela.dyn : AT(ADDR(.rela.dyn) - LOAD_OFFSET)
202	{
203		__rela_dyn_start = .;
204		*(.rela*)
205	}
206#endif
207
208	/* freed after init ends here */
209	. = ALIGN(PAGE_SIZE);
210	__init_end = .;
211
212/*
213 * And now the various read/write data
214 */
215
216	. = ALIGN(PAGE_SIZE);
217	_sdata = .;
218
219#ifdef CONFIG_PPC32
220	.data : AT(ADDR(.data) - LOAD_OFFSET) {
221		DATA_DATA
222		*(.sdata)
223		*(.got.plt) *(.got)
224	}
225#else
226	.data : AT(ADDR(.data) - LOAD_OFFSET) {
227		DATA_DATA
228		*(.data.rel*)
229		*(.toc1)
230		*(.branch_lt)
231	}
232
233	.opd : AT(ADDR(.opd) - LOAD_OFFSET) {
234		*(.opd)
235	}
236
237	.got : AT(ADDR(.got) - LOAD_OFFSET) {
238		__toc_start = .;
239		*(.got)
240		*(.toc)
241	}
242#endif
243
244	. = ALIGN(PAGE_SIZE);
245	_edata  =  .;
246	PROVIDE32 (edata = .);
247
248	/* The initial task and kernel stack */
249#ifdef CONFIG_PPC32
250	. = ALIGN(8192);
251#else
252	. = ALIGN(16384);
253#endif
254	.data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
255		*(.data.init_task)
256	}
257
258	. = ALIGN(PAGE_SIZE);
259	.data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
260		*(.data.page_aligned)
261	}
262
263	.data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
264		*(.data.cacheline_aligned)
265	}
266
267	. = ALIGN(L1_CACHE_BYTES);
268	.data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
269		*(.data.read_mostly)
270	}
271
272	. = ALIGN(PAGE_SIZE);
273	.data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
274		__nosave_begin = .;
275		*(.data.nosave)
276		. = ALIGN(PAGE_SIZE);
277		__nosave_end = .;
278	}
279
280/*
281 * And finally the bss
282 */
283
284	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {
285		__bss_start = .;
286		*(.sbss) *(.scommon)
287		*(.dynbss)
288		*(.bss)
289		*(COMMON)
290		__bss_stop = .;
291	}
292
293	. = ALIGN(PAGE_SIZE);
294	_end = . ;
295	PROVIDE32 (end = .);
296}
297