7fca9355fd3d6a1fffce12d8cc7d09d30a250f36
[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         *(.discard)
44         EXIT_DATA
45         }
46
47         . = KERNELBASE;
48
49 /*
50  * Text, read only data and other permanent read-only sections
51  */
52
53         /* Text and gots */
54         .text : AT(ADDR(.text) - LOAD_OFFSET) {
55                 ALIGN_FUNCTION();
56                 HEAD_TEXT
57                 _text = .;
58                 /* careful! __ftr_alt_* sections need to be close to .text */
59                 *(.text .fixup __ftr_alt_* .ref.text)
60                 SCHED_TEXT
61                 LOCK_TEXT
62                 KPROBES_TEXT
63                 IRQENTRY_TEXT
64
65 #ifdef CONFIG_PPC32
66                 *(.got1)
67                 __got2_start = .;
68                 *(.got2)
69                 __got2_end = .;
70 #endif /* CONFIG_PPC32 */
71
72         } :kernel
73
74         . = ALIGN(PAGE_SIZE);
75         _etext = .;
76         PROVIDE32 (etext = .);
77
78         /* Read-only data */
79         RODATA
80
81         /* Exception & bug tables */
82         __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
83                 __start___ex_table = .;
84                 *(__ex_table)
85                 __stop___ex_table = .;
86         }
87
88         NOTES :kernel :notes
89
90         /* The dummy segment contents for the bug workaround mentioned above
91            near PHDRS.  */
92         .dummy : AT(ADDR(.dummy) - LOAD_OFFSET) {
93                 LONG(0)
94                 LONG(0)
95                 LONG(0)
96         } :kernel :dummy
97
98 /*
99  * Init sections discarded at runtime
100  */
101         . = ALIGN(PAGE_SIZE);
102         __init_begin = .;
103
104         .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
105                 _sinittext = .;
106                 INIT_TEXT
107                 _einittext = .;
108         } :kernel
109
110         /* .exit.text is discarded at runtime, not link time,
111          * to deal with references from __bug_table
112          */
113         .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
114                 EXIT_TEXT
115         }
116
117         .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
118                 INIT_DATA
119                 __vtop_table_begin = .;
120                 *(.vtop_fixup);
121                 __vtop_table_end = .;
122                 __ptov_table_begin = .;
123                 *(.ptov_fixup);
124                 __ptov_table_end = .;
125 #ifdef CONFIG_PPC_ISERIES
126                 __dt_strings_start = .;
127                 *(.dt_strings);
128                 __dt_strings_end = .;
129 #endif
130         }
131
132         . = ALIGN(16);
133         .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
134                 __setup_start = .;
135                 *(.init.setup)
136                 __setup_end = .;
137         }
138
139         .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
140                 __initcall_start = .;
141                 INITCALLS
142                 __initcall_end = .;
143                 }
144
145         .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
146                 __con_initcall_start = .;
147                 *(.con_initcall.init)
148                 __con_initcall_end = .;
149         }
150
151         SECURITY_INIT
152
153         . = ALIGN(8);
154         __ftr_fixup : AT(ADDR(__ftr_fixup) - LOAD_OFFSET) {
155                 __start___ftr_fixup = .;
156                 *(__ftr_fixup)
157                 __stop___ftr_fixup = .;
158         }
159         . = ALIGN(8);
160         __mmu_ftr_fixup : AT(ADDR(__mmu_ftr_fixup) - LOAD_OFFSET) {
161                 __start___mmu_ftr_fixup = .;
162                 *(__mmu_ftr_fixup)
163                 __stop___mmu_ftr_fixup = .;
164         }
165         . = ALIGN(8);
166         __lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
167                 __start___lwsync_fixup = .;
168                 *(__lwsync_fixup)
169                 __stop___lwsync_fixup = .;
170         }
171 #ifdef CONFIG_PPC64
172         . = ALIGN(8);
173         __fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
174                 __start___fw_ftr_fixup = .;
175                 *(__fw_ftr_fixup)
176                 __stop___fw_ftr_fixup = .;
177         }
178 #endif
179 #ifdef CONFIG_BLK_DEV_INITRD
180         . = ALIGN(PAGE_SIZE);
181         .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
182                 __initramfs_start = .;
183                 *(.init.ramfs)
184                 __initramfs_end = .;
185         }
186 #endif
187         PERCPU(PAGE_SIZE)
188
189         . = ALIGN(8);
190         .machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
191                 __machine_desc_start = . ;
192                 *(.machine.desc)
193                 __machine_desc_end = . ;
194         }
195 #ifdef CONFIG_RELOCATABLE
196         . = ALIGN(8);
197         .dynsym : AT(ADDR(.dynsym) - LOAD_OFFSET) { *(.dynsym) }
198         .dynstr : AT(ADDR(.dynstr) - LOAD_OFFSET) { *(.dynstr) }
199         .dynamic : AT(ADDR(.dynamic) - LOAD_OFFSET)
200         {
201                 __dynamic_start = .;
202                 *(.dynamic)
203         }
204         .hash : AT(ADDR(.hash) - LOAD_OFFSET) { *(.hash) }
205         .interp : AT(ADDR(.interp) - LOAD_OFFSET) { *(.interp) }
206         .rela.dyn : AT(ADDR(.rela.dyn) - LOAD_OFFSET)
207         {
208                 __rela_dyn_start = .;
209                 *(.rela*)
210         }
211 #endif
212
213         /* freed after init ends here */
214         . = ALIGN(PAGE_SIZE);
215         __init_end = .;
216
217 /*
218  * And now the various read/write data
219  */
220
221         . = ALIGN(PAGE_SIZE);
222         _sdata = .;
223
224 #ifdef CONFIG_PPC32
225         .data : AT(ADDR(.data) - LOAD_OFFSET) {
226                 DATA_DATA
227                 *(.sdata)
228                 *(.got.plt) *(.got)
229         }
230 #else
231         .data : AT(ADDR(.data) - LOAD_OFFSET) {
232                 DATA_DATA
233                 *(.data.rel*)
234                 *(.toc1)
235                 *(.branch_lt)
236         }
237
238         .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
239                 *(.opd)
240         }
241
242         .got : AT(ADDR(.got) - LOAD_OFFSET) {
243                 __toc_start = .;
244                 *(.got)
245                 *(.toc)
246         }
247 #endif
248
249         . = ALIGN(PAGE_SIZE);
250         _edata  =  .;
251         PROVIDE32 (edata = .);
252
253         /* The initial task and kernel stack */
254 #ifdef CONFIG_PPC32
255         . = ALIGN(8192);
256 #else
257         . = ALIGN(16384);
258 #endif
259         .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
260                 *(.data.init_task)
261         }
262
263         . = ALIGN(PAGE_SIZE);
264         .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
265                 *(.data.page_aligned)
266         }
267
268         . = ALIGN(L1_CACHE_BYTES);
269         .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
270                 *(.data.cacheline_aligned)
271         }
272
273         . = ALIGN(L1_CACHE_BYTES);
274         .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
275                 *(.data.read_mostly)
276         }
277
278         . = ALIGN(PAGE_SIZE);
279         .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
280                 __nosave_begin = .;
281                 *(.data.nosave)
282                 . = ALIGN(PAGE_SIZE);
283                 __nosave_end = .;
284         }
285
286 /*
287  * And finally the bss
288  */
289
290         .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
291                 __bss_start = .;
292                 *(.sbss) *(.scommon)
293                 *(.dynbss)
294                 *(.bss)
295                 *(COMMON)
296                 __bss_stop = .;
297         }
298
299         . = ALIGN(PAGE_SIZE);
300         _end = . ;
301         PROVIDE32 (end = .);
302 }