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