04e8ecea9b40ad6d886ea58aa1f4db06e06f2526
[linux-2.6.git] / arch / powerpc / kernel / vmlinux.lds.S
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
10 ENTRY(_stext)
11
12 PHDRS {
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
32 OUTPUT_ARCH(powerpc:common64)
33 jiffies = jiffies_64;
34 #else
35 OUTPUT_ARCH(powerpc:common)
36 jiffies = jiffies_64 + 4;
37 #endif
38 SECTIONS
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         __mmu_ftr_fixup : AT(ADDR(__mmu_ftr_fixup) - LOAD_OFFSET) {
156                 __start___mmu_ftr_fixup = .;
157                 *(__mmu_ftr_fixup)
158                 __stop___mmu_ftr_fixup = .;
159         }
160         . = ALIGN(8);
161         __lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
162                 __start___lwsync_fixup = .;
163                 *(__lwsync_fixup)
164                 __stop___lwsync_fixup = .;
165         }
166 #ifdef CONFIG_PPC64
167         . = ALIGN(8);
168         __fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
169                 __start___fw_ftr_fixup = .;
170                 *(__fw_ftr_fixup)
171                 __stop___fw_ftr_fixup = .;
172         }
173 #endif
174 #ifdef CONFIG_BLK_DEV_INITRD
175         . = ALIGN(PAGE_SIZE);
176         .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
177                 __initramfs_start = .;
178                 *(.init.ramfs)
179                 __initramfs_end = .;
180         }
181 #endif
182         . = ALIGN(PAGE_SIZE);
183         .data.percpu  : AT(ADDR(.data.percpu) - LOAD_OFFSET) {
184                 __per_cpu_start = .;
185                 *(.data.percpu.page_aligned)
186                 *(.data.percpu)
187                 *(.data.percpu.shared_aligned)
188                 __per_cpu_end = .;
189         }
190
191         . = ALIGN(8);
192         .machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
193                 __machine_desc_start = . ;
194                 *(.machine.desc)
195                 __machine_desc_end = . ;
196         }
197 #ifdef CONFIG_RELOCATABLE
198         . = ALIGN(8);
199         .dynsym : AT(ADDR(.dynsym) - LOAD_OFFSET) { *(.dynsym) }
200         .dynstr : AT(ADDR(.dynstr) - LOAD_OFFSET) { *(.dynstr) }
201         .dynamic : AT(ADDR(.dynamic) - LOAD_OFFSET)
202         {
203                 __dynamic_start = .;
204                 *(.dynamic)
205         }
206         .hash : AT(ADDR(.hash) - LOAD_OFFSET) { *(.hash) }
207         .interp : AT(ADDR(.interp) - LOAD_OFFSET) { *(.interp) }
208         .rela.dyn : AT(ADDR(.rela.dyn) - LOAD_OFFSET)
209         {
210                 __rela_dyn_start = .;
211                 *(.rela*)
212         }
213 #endif
214
215         /* freed after init ends here */
216         . = ALIGN(PAGE_SIZE);
217         __init_end = .;
218
219 /*
220  * And now the various read/write data
221  */
222
223         . = ALIGN(PAGE_SIZE);
224         _sdata = .;
225
226 #ifdef CONFIG_PPC32
227         .data : AT(ADDR(.data) - LOAD_OFFSET) {
228                 DATA_DATA
229                 *(.sdata)
230                 *(.got.plt) *(.got)
231         }
232 #else
233         .data : AT(ADDR(.data) - LOAD_OFFSET) {
234                 DATA_DATA
235                 *(.data.rel*)
236                 *(.toc1)
237                 *(.branch_lt)
238         }
239
240         .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
241                 *(.opd)
242         }
243
244         .got : AT(ADDR(.got) - LOAD_OFFSET) {
245                 __toc_start = .;
246                 *(.got)
247                 *(.toc)
248         }
249 #endif
250
251         . = ALIGN(PAGE_SIZE);
252         _edata  =  .;
253         PROVIDE32 (edata = .);
254
255         /* The initial task and kernel stack */
256 #ifdef CONFIG_PPC32
257         . = ALIGN(8192);
258 #else
259         . = ALIGN(16384);
260 #endif
261         .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
262                 *(.data.init_task)
263         }
264
265         . = ALIGN(PAGE_SIZE);
266         .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
267                 *(.data.page_aligned)
268         }
269
270         .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
271                 *(.data.cacheline_aligned)
272         }
273
274         . = ALIGN(L1_CACHE_BYTES);
275         .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
276                 *(.data.read_mostly)
277         }
278
279         . = ALIGN(PAGE_SIZE);
280         .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
281                 __nosave_begin = .;
282                 *(.data.nosave)
283                 . = ALIGN(PAGE_SIZE);
284                 __nosave_end = .;
285         }
286
287 /*
288  * And finally the bss
289  */
290
291         .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
292                 __bss_start = .;
293                 *(.sbss) *(.scommon)
294                 *(.dynbss)
295                 *(.bss)
296                 *(COMMON)
297                 __bss_stop = .;
298         }
299
300         . = ALIGN(PAGE_SIZE);
301         _end = . ;
302         PROVIDE32 (end = .);
303 }