Merge branch 'x86/mm' into core/percpu
[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(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         . = ALIGN(PAGE_SIZE);
185         .data.percpu  : AT(ADDR(.data.percpu) - LOAD_OFFSET) {
186                 __per_cpu_start = .;
187                 *(.data.percpu.page_aligned)
188                 *(.data.percpu)
189                 *(.data.percpu.shared_aligned)
190                 __per_cpu_end = .;
191         }
192
193         . = ALIGN(8);
194         .machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
195                 __machine_desc_start = . ;
196                 *(.machine.desc)
197                 __machine_desc_end = . ;
198         }
199 #ifdef CONFIG_RELOCATABLE
200         . = ALIGN(8);
201         .dynsym : AT(ADDR(.dynsym) - LOAD_OFFSET) { *(.dynsym) }
202         .dynstr : AT(ADDR(.dynstr) - LOAD_OFFSET) { *(.dynstr) }
203         .dynamic : AT(ADDR(.dynamic) - LOAD_OFFSET)
204         {
205                 __dynamic_start = .;
206                 *(.dynamic)
207         }
208         .hash : AT(ADDR(.hash) - LOAD_OFFSET) { *(.hash) }
209         .interp : AT(ADDR(.interp) - LOAD_OFFSET) { *(.interp) }
210         .rela.dyn : AT(ADDR(.rela.dyn) - LOAD_OFFSET)
211         {
212                 __rela_dyn_start = .;
213                 *(.rela*)
214         }
215 #endif
216
217         /* freed after init ends here */
218         . = ALIGN(PAGE_SIZE);
219         __init_end = .;
220
221 /*
222  * And now the various read/write data
223  */
224
225         . = ALIGN(PAGE_SIZE);
226         _sdata = .;
227
228 #ifdef CONFIG_PPC32
229         .data : AT(ADDR(.data) - LOAD_OFFSET) {
230                 DATA_DATA
231                 *(.sdata)
232                 *(.got.plt) *(.got)
233         }
234 #else
235         .data : AT(ADDR(.data) - LOAD_OFFSET) {
236                 DATA_DATA
237                 *(.data.rel*)
238                 *(.toc1)
239                 *(.branch_lt)
240         }
241
242         .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
243                 *(.opd)
244         }
245
246         .got : AT(ADDR(.got) - LOAD_OFFSET) {
247                 __toc_start = .;
248                 *(.got)
249                 *(.toc)
250         }
251 #endif
252
253         . = ALIGN(PAGE_SIZE);
254         _edata  =  .;
255         PROVIDE32 (edata = .);
256
257         /* The initial task and kernel stack */
258 #ifdef CONFIG_PPC32
259         . = ALIGN(8192);
260 #else
261         . = ALIGN(16384);
262 #endif
263         .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
264                 *(.data.init_task)
265         }
266
267         . = ALIGN(PAGE_SIZE);
268         .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
269                 *(.data.page_aligned)
270         }
271
272         .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
273                 *(.data.cacheline_aligned)
274         }
275
276         . = ALIGN(L1_CACHE_BYTES);
277         .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
278                 *(.data.read_mostly)
279         }
280
281         . = ALIGN(PAGE_SIZE);
282         .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
283                 __nosave_begin = .;
284                 *(.data.nosave)
285                 . = ALIGN(PAGE_SIZE);
286                 __nosave_end = .;
287         }
288
289 /*
290  * And finally the bss
291  */
292
293         .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
294                 __bss_start = .;
295                 *(.sbss) *(.scommon)
296                 *(.dynbss)
297                 *(.bss)
298                 *(COMMON)
299                 __bss_stop = .;
300         }
301
302         . = ALIGN(PAGE_SIZE);
303         _end = . ;
304         PROVIDE32 (end = .);
305 }