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