b1e24638acd7c3b2040cad8ea1487b85ec78fa8e
[linux-2.6.git] / arch / xtensa / kernel / vmlinux.lds.S
1 /*
2  * arch/xtensa/kernel/vmlinux.lds.S
3  *
4  * Xtensa linker script
5  *
6  * This file is subject to the terms and conditions of the GNU General Public
7  * License.  See the file "COPYING" in the main directory of this archive
8  * for more details.
9  *
10  * Copyright (C) 2001 - 2005 Tensilica Inc.
11  *
12  * Chris Zankel <chris@zankel.net>
13  * Marc Gauthier <marc@tensilica.com, marc@alumni.uwaterloo.ca>
14  * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
15  */
16
17 #include <asm-generic/vmlinux.lds.h>
18
19 #include <variant/core.h>
20 #include <platform/hardware.h>
21 OUTPUT_ARCH(xtensa)
22 ENTRY(_start)
23
24 #ifdef __XTENSA_EB__
25 jiffies = jiffies_64 + 4;
26 #else
27 jiffies = jiffies_64;
28 #endif
29
30 #ifndef KERNELOFFSET
31 #define KERNELOFFSET 0xd0001000
32 #endif
33
34 /* Note: In the following macros, it would be nice to specify only the
35    vector name and section kind and construct "sym" and "section" using
36    CPP concatenation, but that does not work reliably.  Concatenating a
37    string with "." produces an invalid token.  CPP will not print a
38    warning because it thinks this is an assembly file, but it leaves
39    them as multiple tokens and there may or may not be whitespace
40    between them.  */
41
42 /* Macro for a relocation entry */
43
44 #define RELOCATE_ENTRY(sym, section)            \
45         LONG(sym ## _start);                    \
46         LONG(sym ## _end);                      \
47         LONG(LOADADDR(section))
48
49 /* Macro to define a section for a vector.
50  *
51  * Use of the MIN function catches the types of errors illustrated in
52  * the following example:
53  *
54  * Assume the section .DoubleExceptionVector.literal is completely
55  * full.  Then a programmer adds code to .DoubleExceptionVector.text
56  * that produces another literal.  The final literal position will
57  * overlay onto the first word of the adjacent code section
58  * .DoubleExceptionVector.text.  (In practice, the literals will
59  * overwrite the code, and the first few instructions will be
60  * garbage.)
61  */
62
63 #define SECTION_VECTOR(sym, section, addr, max_prevsec_size, prevsec)       \
64   section addr : AT((MIN(LOADADDR(prevsec) + max_prevsec_size,              \
65                          LOADADDR(prevsec) + SIZEOF(prevsec)) + 3) & ~ 3)   \
66   {                                                                         \
67     . = ALIGN(4);                                                           \
68     sym ## _start = ABSOLUTE(.);                                            \
69     *(section)                                                              \
70     sym ## _end = ABSOLUTE(.);                                              \
71   }
72
73 /*
74  *  Mapping of input sections to output sections when linking.
75  */
76
77 SECTIONS
78 {
79   . = KERNELOFFSET;
80   /* .text section */
81
82   _text = .;
83   _stext = .;
84   _ftext = .;
85
86   .text :
87   {
88     /* The HEAD_TEXT section must be the first section! */
89     HEAD_TEXT
90     TEXT_TEXT
91     VMLINUX_SYMBOL(__sched_text_start) = .;
92     *(.sched.literal .sched.text)
93     VMLINUX_SYMBOL(__sched_text_end) = .;
94     VMLINUX_SYMBOL(__lock_text_start) = .;
95     *(.spinlock.literal .spinlock.text)
96     VMLINUX_SYMBOL(__lock_text_end) = .;
97
98   }
99   _etext = .;
100   PROVIDE (etext = .);
101
102   . = ALIGN(16);
103
104   RODATA
105
106   /*  Relocation table */
107
108   .fixup   : { *(.fixup) }
109
110   . = ALIGN(16);
111
112   __ex_table : {
113     __start___ex_table = .;
114     *(__ex_table)
115     __stop___ex_table = .;
116   }
117
118   /* Data section */
119
120   . = ALIGN(XCHAL_ICACHE_LINESIZE);
121   _fdata = .;
122   .data :
123   {
124     DATA_DATA
125     CONSTRUCTORS
126     . = ALIGN(XCHAL_ICACHE_LINESIZE);
127     *(.data.cacheline_aligned)
128   }
129
130   _edata = .;
131
132   /* The initial task */
133   . = ALIGN(8192);
134   .data.init_task : { *(.data.init_task) }
135
136   /* Initialization code and data: */
137
138   . = ALIGN(1 << 12);
139   __init_begin = .;
140   .init.text : {
141         _sinittext = .;
142         INIT_TEXT
143         _einittext = .;
144   }
145
146   .init.data :
147   {
148     INIT_DATA
149     . = ALIGN(0x4);
150     __tagtable_begin = .;
151     *(.taglist)
152     __tagtable_end = .;
153
154     . = ALIGN(16);
155     __boot_reloc_table_start = ABSOLUTE(.);
156
157     RELOCATE_ENTRY(_WindowVectors_text,
158                    .WindowVectors.text);
159     RELOCATE_ENTRY(_KernelExceptionVector_text,
160                    .KernelExceptionVector.text);
161     RELOCATE_ENTRY(_UserExceptionVector_text,
162                    .UserExceptionVector.text);
163     RELOCATE_ENTRY(_DoubleExceptionVector_literal,
164                    .DoubleExceptionVector.literal);
165     RELOCATE_ENTRY(_DoubleExceptionVector_text,
166                    .DoubleExceptionVector.text);
167     RELOCATE_ENTRY(_DebugInterruptVector_text,
168                    .DebugInterruptVector.text);
169   
170     __boot_reloc_table_end = ABSOLUTE(.) ;
171   }
172
173   . = ALIGN(XCHAL_ICACHE_LINESIZE);
174
175   __setup_start = .;
176   .init.setup : { *(.init.setup) }
177   __setup_end = .;
178
179   __initcall_start = .;
180   .initcall.init : {
181         INITCALLS
182   }
183   __initcall_end = .;
184
185   __con_initcall_start = .;
186   .con_initcall.init : { *(.con_initcall.init) }
187   __con_initcall_end = .;
188
189   SECURITY_INIT
190
191
192 #ifdef CONFIG_BLK_DEV_INITRD
193   . = ALIGN(4096);
194   __initramfs_start =.;
195   .init.ramfs : { *(.init.ramfs) }
196   __initramfs_end = .;
197 #endif
198
199   PERCPU(4096)
200
201
202   /* We need this dummy segment here */
203
204   . = ALIGN(4);
205   .dummy : { LONG(0) }
206
207   /* The vectors are relocated to the real position at startup time */
208
209   SECTION_VECTOR (_WindowVectors_text,
210                   .WindowVectors.text,
211                   XCHAL_WINDOW_VECTORS_VADDR, 4,
212                   .dummy)
213   SECTION_VECTOR (_DebugInterruptVector_literal,
214                   .DebugInterruptVector.literal,
215                   XCHAL_DEBUG_VECTOR_VADDR - 4,
216                   SIZEOF(.WindowVectors.text),
217                   .WindowVectors.text)
218   SECTION_VECTOR (_DebugInterruptVector_text,
219                   .DebugInterruptVector.text,
220                   XCHAL_DEBUG_VECTOR_VADDR,
221                   4,
222                   .DebugInterruptVector.literal)
223   SECTION_VECTOR (_KernelExceptionVector_literal,
224                   .KernelExceptionVector.literal,
225                   XCHAL_KERNEL_VECTOR_VADDR - 4,
226                   SIZEOF(.DebugInterruptVector.text),
227                   .DebugInterruptVector.text)
228   SECTION_VECTOR (_KernelExceptionVector_text,
229                   .KernelExceptionVector.text,
230                   XCHAL_KERNEL_VECTOR_VADDR,
231                   4,
232                   .KernelExceptionVector.literal)
233   SECTION_VECTOR (_UserExceptionVector_literal,
234                   .UserExceptionVector.literal,
235                   XCHAL_USER_VECTOR_VADDR - 4,
236                   SIZEOF(.KernelExceptionVector.text),
237                   .KernelExceptionVector.text)
238   SECTION_VECTOR (_UserExceptionVector_text,
239                   .UserExceptionVector.text,
240                   XCHAL_USER_VECTOR_VADDR,
241                   4,
242                   .UserExceptionVector.literal)
243   SECTION_VECTOR (_DoubleExceptionVector_literal,
244                   .DoubleExceptionVector.literal,
245                   XCHAL_DOUBLEEXC_VECTOR_VADDR - 16,
246                   SIZEOF(.UserExceptionVector.text),
247                   .UserExceptionVector.text)
248   SECTION_VECTOR (_DoubleExceptionVector_text,
249                   .DoubleExceptionVector.text,
250                   XCHAL_DOUBLEEXC_VECTOR_VADDR,
251                   32,
252                   .DoubleExceptionVector.literal)
253
254   . = (LOADADDR( .DoubleExceptionVector.text ) + SIZEOF( .DoubleExceptionVector.text ) + 3) & ~ 3;
255   . = ALIGN(1 << 12);
256
257   __init_end = .;
258
259   . = ALIGN(8192);
260
261   /* BSS section */
262   _bss_start = .;
263   .bss : { *(.bss.page_aligned) *(.bss) }
264   _bss_end = .;
265
266   _end = .;
267
268   /* only used by the boot loader  */
269
270   . = ALIGN(0x10);
271   .bootstrap : { *(.bootstrap.literal .bootstrap.text .bootstrap.data) }
272
273   . = ALIGN(0x1000);
274   __initrd_start = .;
275   .initrd : { *(.initrd) }
276   __initrd_end = .;
277
278   .ResetVector.text XCHAL_RESET_VECTOR_VADDR :
279   {
280     *(.ResetVector.text)
281   }
282
283   /* Sections to be discarded */
284   /DISCARD/ :
285   {
286         *(.exit.literal)
287         EXIT_TEXT
288         EXIT_DATA
289         *(.exitcall.exit)
290         *(.discard)
291   }
292
293   .xt.lit : { *(.xt.lit) }
294   .xt.prop : { *(.xt.prop) }
295
296   .debug  0 :  { *(.debug) }
297   .line  0 :  { *(.line) }
298   .debug_srcinfo  0 :  { *(.debug_srcinfo) }
299   .debug_sfnames  0 :  { *(.debug_sfnames) }
300   .debug_aranges  0 :  { *(.debug_aranges) }
301   .debug_pubnames  0 :  { *(.debug_pubnames) }
302   .debug_info  0 :  { *(.debug_info) }
303   .debug_abbrev  0 :  { *(.debug_abbrev) }
304   .debug_line  0 :  { *(.debug_line) }
305   .debug_frame  0 :  { *(.debug_frame) }
306   .debug_str  0 :  { *(.debug_str) }
307   .debug_loc  0 :  { *(.debug_loc) }
308   .debug_macinfo  0 :  { *(.debug_macinfo) }
309   .debug_weaknames  0 :  { *(.debug_weaknames) }
310   .debug_funcnames  0 :  { *(.debug_funcnames) }
311   .debug_typenames  0 :  { *(.debug_typenames) }
312   .debug_varnames  0 :  { *(.debug_varnames) }
313
314   .xt.insn 0 :
315   {
316     *(.xt.insn)
317     *(.gnu.linkonce.x*)
318   }
319
320   .xt.lit 0 :
321   {
322     *(.xt.lit)
323     *(.gnu.linkonce.p*)
324   }
325 }