]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - arch/blackfin/kernel/vmlinux.lds.S
blackfin: Cleanup linker script using new linker script macros.
[linux-2.6.git] / arch / blackfin / kernel / vmlinux.lds.S
1 /*
2  * File:         arch/blackfin/kernel/vmlinux.lds.S
3  * Based on:     none - original work
4  * Author:
5  *
6  * Created:      Tue Sep 21 2004
7  * Description:  Master linker script for blackfin architecture
8  *
9  * Modified:
10  *               Copyright 2004-2007 Analog Devices Inc.
11  *
12  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, see the file COPYING, or write
26  * to the Free Software Foundation, Inc.,
27  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
28  */
29
30 #define VMLINUX_SYMBOL(_sym_) _##_sym_
31
32 #include <asm-generic/vmlinux.lds.h>
33 #include <asm/mem_map.h>
34 #include <asm/page.h>
35 #include <asm/thread_info.h>
36
37 OUTPUT_FORMAT("elf32-bfin")
38 ENTRY(__start)
39 _jiffies = _jiffies_64;
40
41 SECTIONS
42 {
43         . = CONFIG_BOOT_LOAD;
44         /* Neither the text, ro_data or bss section need to be aligned
45          * So pack them back to back
46          */
47         .text :
48         {
49                 __text = .;
50                 _text = .;
51                 __stext = .;
52                 TEXT_TEXT
53 #ifndef CONFIG_SCHEDULE_L1
54                 SCHED_TEXT
55 #endif
56                 LOCK_TEXT
57                 IRQENTRY_TEXT
58                 KPROBES_TEXT
59                 *(.text.*)
60                 *(.fixup)
61
62 #if !L1_CODE_LENGTH
63                 *(.l1.text)
64 #endif
65
66                 . = ALIGN(16);
67                 ___start___ex_table = .;
68                 *(__ex_table)
69                 ___stop___ex_table = .;
70
71                 __etext = .;
72         }
73
74         NOTES
75
76         /* Just in case the first read only is a 32-bit access */
77         RO_DATA(4)
78
79         .bss :
80         {
81                 . = ALIGN(4);
82                 ___bss_start = .;
83                 *(.bss .bss.*)
84                 *(COMMON)
85 #if !L1_DATA_A_LENGTH
86                 *(.l1.bss)
87 #endif
88 #if !L1_DATA_B_LENGTH
89                 *(.l1.bss.B)
90 #endif
91                 . = ALIGN(4);
92                 ___bss_stop = .;
93         }
94
95         .data :
96         {
97                 __sdata = .;
98                 /* This gets done first, so the glob doesn't suck it in */
99                 CACHELINE_ALIGNED_DATA(32)
100
101 #if !L1_DATA_A_LENGTH
102                 . = ALIGN(32);
103                 *(.data_l1.cacheline_aligned)
104                 *(.l1.data)
105 #endif
106 #if !L1_DATA_B_LENGTH
107                 *(.l1.data.B)
108 #endif
109 #if !L2_LENGTH
110                 . = ALIGN(32);
111                 *(.data_l2.cacheline_aligned)
112                 *(.l2.data)
113 #endif
114
115                 DATA_DATA
116                 CONSTRUCTORS
117
118                 INIT_TASK_DATA(THREAD_SIZE)
119
120                 __edata = .;
121         }
122
123         /* The init section should be last, so when we free it, it goes into
124          * the general memory pool, and (hopefully) will decrease fragmentation
125          * a tiny bit. The init section has a _requirement_ that it be
126          * PAGE_SIZE aligned
127          */
128         . = ALIGN(PAGE_SIZE);
129         ___init_begin = .;
130
131         INIT_TEXT_SECTION(PAGE_SIZE)
132         . = ALIGN(16);
133         INIT_DATA_SECTION(16)
134         PERCPU(4)
135
136         /* we have to discard exit text and such at runtime, not link time, to
137          * handle embedded cross-section references (alt instructions, bug
138          * table, eh_frame, etc...)
139          */
140         .exit.text :
141         {
142                 EXIT_TEXT
143         }
144         .exit.data :
145         {
146                 EXIT_DATA
147         }
148
149         __l1_lma_start = .;
150
151         .text_l1 L1_CODE_START : AT(LOADADDR(.exit.data) + SIZEOF(.exit.data))
152         {
153                 . = ALIGN(4);
154                 __stext_l1 = .;
155                 *(.l1.text)
156 #ifdef CONFIG_SCHEDULE_L1
157                 SCHED_TEXT
158 #endif
159                 . = ALIGN(4);
160                 __etext_l1 = .;
161         }
162         ASSERT (SIZEOF(.text_l1) <= L1_CODE_LENGTH, "L1 text overflow!")
163
164         .data_l1 L1_DATA_A_START : AT(LOADADDR(.text_l1) + SIZEOF(.text_l1))
165         {
166                 . = ALIGN(4);
167                 __sdata_l1 = .;
168                 *(.l1.data)
169                 __edata_l1 = .;
170
171                 . = ALIGN(32);
172                 *(.data_l1.cacheline_aligned)
173
174                 . = ALIGN(4);
175                 __sbss_l1 = .;
176                 *(.l1.bss)
177                 . = ALIGN(4);
178                 __ebss_l1 = .;
179         }
180         ASSERT (SIZEOF(.data_l1) <= L1_DATA_A_LENGTH, "L1 data A overflow!")
181
182         .data_b_l1 L1_DATA_B_START : AT(LOADADDR(.data_l1) + SIZEOF(.data_l1))
183         {
184                 . = ALIGN(4);
185                 __sdata_b_l1 = .;
186                 *(.l1.data.B)
187                 __edata_b_l1 = .;
188
189                 . = ALIGN(4);
190                 __sbss_b_l1 = .;
191                 *(.l1.bss.B)
192                 . = ALIGN(4);
193                 __ebss_b_l1 = .;
194         }
195         ASSERT (SIZEOF(.data_b_l1) <= L1_DATA_B_LENGTH, "L1 data B overflow!")
196
197         __l2_lma_start = LOADADDR(.data_b_l1) + SIZEOF(.data_b_l1);
198
199         .text_data_l2 L2_START : AT(LOADADDR(.data_b_l1) + SIZEOF(.data_b_l1))
200         {
201                 . = ALIGN(4);
202                 __stext_l2 = .;
203                 *(.l2.text)
204                 . = ALIGN(4);
205                 __etext_l2 = .;
206
207                 . = ALIGN(4);
208                 __sdata_l2 = .;
209                 *(.l2.data)
210                 __edata_l2 = .;
211
212                 . = ALIGN(32);
213                 *(.data_l2.cacheline_aligned)
214
215                 . = ALIGN(4);
216                 __sbss_l2 = .;
217                 *(.l2.bss)
218                 . = ALIGN(4);
219                 __ebss_l2 = .;
220         }
221         ASSERT (SIZEOF(.text_data_l2) <= L2_LENGTH, "L2 overflow!")
222
223         /* Force trailing alignment of our init section so that when we
224          * free our init memory, we don't leave behind a partial page.
225          */
226         . = LOADADDR(.text_data_l2) + SIZEOF(.text_data_l2);
227         . = ALIGN(PAGE_SIZE);
228         ___init_end = .;
229
230         __end =.;
231
232         STABS_DEBUG
233
234         DWARF_DEBUG
235
236         DISCARDS
237 }