Rename .data.init_task to .data..init_task.
[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 #include <asm/thread_info.h>
10
11 ENTRY(_stext)
12
13 PHDRS {
14         kernel PT_LOAD FLAGS(7); /* RWX */
15         notes PT_NOTE FLAGS(0);
16         dummy PT_NOTE FLAGS(0);
17
18         /* binutils < 2.18 has a bug that makes it misbehave when taking an
19            ELF file with all segments at load address 0 as input.  This
20            happens when running "strip" on vmlinux, because of the AT() magic
21            in this linker script.  People using GCC >= 4.2 won't run into
22            this problem, because the "build-id" support will put some data
23            into the "notes" segment (at a non-zero load address).
24
25            To work around this, we force some data into both the "dummy"
26            segment and the kernel segment, so the dummy segment will get a
27            non-zero load address.  It's not enough to always create the
28            "notes" segment, since if nothing gets assigned to it, its load
29            address will be zero.  */
30 }
31
32 #ifdef CONFIG_PPC64
33 OUTPUT_ARCH(powerpc:common64)
34 jiffies = jiffies_64;
35 #else
36 OUTPUT_ARCH(powerpc:common)
37 jiffies = jiffies_64 + 4;
38 #endif
39 SECTIONS
40 {
41         . = 0;
42         reloc_start = .;
43
44         . = KERNELBASE;
45
46 /*
47  * Text, read only data and other permanent read-only sections
48  */
49
50         /* Text and gots */
51         .text : AT(ADDR(.text) - LOAD_OFFSET) {
52                 ALIGN_FUNCTION();
53                 HEAD_TEXT
54                 _text = .;
55                 /* careful! __ftr_alt_* sections need to be close to .text */
56                 *(.text .fixup __ftr_alt_* .ref.text)
57                 SCHED_TEXT
58                 LOCK_TEXT
59                 KPROBES_TEXT
60                 IRQENTRY_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_TABLE(0)
79
80         NOTES :kernel :notes
81
82         /* The dummy segment contents for the bug workaround mentioned above
83            near PHDRS.  */
84         .dummy : AT(ADDR(.dummy) - LOAD_OFFSET) {
85                 LONG(0)
86                 LONG(0)
87                 LONG(0)
88         } :kernel :dummy
89
90 /*
91  * Init sections discarded at runtime
92  */
93         . = ALIGN(PAGE_SIZE);
94         __init_begin = .;
95         INIT_TEXT_SECTION(PAGE_SIZE) :kernel
96
97         /* .exit.text is discarded at runtime, not link time,
98          * to deal with references from __bug_table
99          */
100         .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
101                 EXIT_TEXT
102         }
103
104         .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
105                 INIT_DATA
106                 __vtop_table_begin = .;
107                 *(.vtop_fixup);
108                 __vtop_table_end = .;
109                 __ptov_table_begin = .;
110                 *(.ptov_fixup);
111                 __ptov_table_end = .;
112 #ifdef CONFIG_PPC_ISERIES
113                 __dt_strings_start = .;
114                 *(.dt_strings);
115                 __dt_strings_end = .;
116 #endif
117         }
118
119         .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
120                 INIT_SETUP(16)
121         }
122
123         .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
124                 INIT_CALLS
125         }
126
127         .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
128                 CON_INITCALL
129         }
130
131         SECURITY_INIT
132
133         . = ALIGN(8);
134         __ftr_fixup : AT(ADDR(__ftr_fixup) - LOAD_OFFSET) {
135                 __start___ftr_fixup = .;
136                 *(__ftr_fixup)
137                 __stop___ftr_fixup = .;
138         }
139         . = ALIGN(8);
140         __mmu_ftr_fixup : AT(ADDR(__mmu_ftr_fixup) - LOAD_OFFSET) {
141                 __start___mmu_ftr_fixup = .;
142                 *(__mmu_ftr_fixup)
143                 __stop___mmu_ftr_fixup = .;
144         }
145         . = ALIGN(8);
146         __lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
147                 __start___lwsync_fixup = .;
148                 *(__lwsync_fixup)
149                 __stop___lwsync_fixup = .;
150         }
151 #ifdef CONFIG_PPC64
152         . = ALIGN(8);
153         __fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
154                 __start___fw_ftr_fixup = .;
155                 *(__fw_ftr_fixup)
156                 __stop___fw_ftr_fixup = .;
157         }
158 #endif
159         .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
160                 INIT_RAM_FS
161         }
162
163         PERCPU(PAGE_SIZE)
164
165         . = ALIGN(8);
166         .machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
167                 __machine_desc_start = . ;
168                 *(.machine.desc)
169                 __machine_desc_end = . ;
170         }
171 #ifdef CONFIG_RELOCATABLE
172         . = ALIGN(8);
173         .dynsym : AT(ADDR(.dynsym) - LOAD_OFFSET) { *(.dynsym) }
174         .dynstr : AT(ADDR(.dynstr) - LOAD_OFFSET) { *(.dynstr) }
175         .dynamic : AT(ADDR(.dynamic) - LOAD_OFFSET)
176         {
177                 __dynamic_start = .;
178                 *(.dynamic)
179         }
180         .hash : AT(ADDR(.hash) - LOAD_OFFSET) { *(.hash) }
181         .interp : AT(ADDR(.interp) - LOAD_OFFSET) { *(.interp) }
182         .rela.dyn : AT(ADDR(.rela.dyn) - LOAD_OFFSET)
183         {
184                 __rela_dyn_start = .;
185                 *(.rela*)
186         }
187 #endif
188
189         /* freed after init ends here */
190         . = ALIGN(PAGE_SIZE);
191         __init_end = .;
192
193 /*
194  * And now the various read/write data
195  */
196
197         . = ALIGN(PAGE_SIZE);
198         _sdata = .;
199
200 #ifdef CONFIG_PPC32
201         .data : AT(ADDR(.data) - LOAD_OFFSET) {
202                 DATA_DATA
203                 *(.sdata)
204                 *(.got.plt) *(.got)
205         }
206 #else
207         .data : AT(ADDR(.data) - LOAD_OFFSET) {
208                 DATA_DATA
209                 *(.data.rel*)
210                 *(.toc1)
211                 *(.branch_lt)
212         }
213
214         .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
215                 *(.opd)
216         }
217
218         .got : AT(ADDR(.got) - LOAD_OFFSET) {
219                 __toc_start = .;
220                 *(.got)
221                 *(.toc)
222         }
223 #endif
224
225         /* The initial task and kernel stack */
226         INIT_TASK_DATA_SECTION(THREAD_SIZE)
227
228         .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
229                 PAGE_ALIGNED_DATA(PAGE_SIZE)
230         }
231
232         .data..cacheline_aligned : AT(ADDR(.data..cacheline_aligned) - LOAD_OFFSET) {
233                 CACHELINE_ALIGNED_DATA(L1_CACHE_BYTES)
234         }
235
236         .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
237                 READ_MOSTLY_DATA(L1_CACHE_BYTES)
238         }
239
240         . = ALIGN(PAGE_SIZE);
241         .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
242                 NOSAVE_DATA
243         }
244
245         . = ALIGN(PAGE_SIZE);
246         _edata  =  .;
247         PROVIDE32 (edata = .);
248
249 /*
250  * And finally the bss
251  */
252
253         BSS_SECTION(0, 0, 0)
254
255         . = ALIGN(PAGE_SIZE);
256         _end = . ;
257         PROVIDE32 (end = .);
258
259         /* Sections to be discarded. */
260         DISCARDS
261 }