1283614c9b247674ee75fd865744c9a95d902379
[linux-2.6.git] / arch / x86_64 / kernel / vmlinux.lds.S
1 /* ld script to make x86-64 Linux kernel
2  * Written by Martin Mares <mj@atrey.karlin.mff.cuni.cz>;
3  */
4
5 #define LOAD_OFFSET __START_KERNEL_map
6
7 #include <asm-generic/vmlinux.lds.h>
8 #include <asm/page.h>
9
10 #undef i386     /* in case the preprocessor is a 32bit one */
11
12 OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
13 OUTPUT_ARCH(i386:x86-64)
14 ENTRY(phys_startup_64)
15 jiffies_64 = jiffies;
16 PHDRS {
17         text PT_LOAD FLAGS(5);  /* R_E */
18         data PT_LOAD FLAGS(7);  /* RWE */
19         user PT_LOAD FLAGS(7);  /* RWE */
20         data.init PT_LOAD FLAGS(7);     /* RWE */
21         note PT_NOTE FLAGS(4);  /* R__ */
22 }
23 SECTIONS
24 {
25   . = __START_KERNEL;
26   phys_startup_64 = startup_64 - LOAD_OFFSET;
27   _text = .;                    /* Text and read-only data */
28   .text :  AT(ADDR(.text) - LOAD_OFFSET) {
29         /* First the code that has to be first for bootstrapping */
30         *(.bootstrap.text)
31         /* Then all the functions that are "hot" in profiles, to group them
32            onto the same hugetlb entry */
33         #include "functionlist"
34         /* Then the rest */
35         *(.text)
36         SCHED_TEXT
37         LOCK_TEXT
38         KPROBES_TEXT
39         *(.fixup)
40         *(.gnu.warning)
41         } :text = 0x9090
42                                 /* out-of-line lock text */
43   .text.lock : AT(ADDR(.text.lock) - LOAD_OFFSET) { *(.text.lock) }
44
45   _etext = .;                   /* End of text section */
46
47   . = ALIGN(16);                /* Exception table */
48   __start___ex_table = .;
49   __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) { *(__ex_table) }
50   __stop___ex_table = .;
51
52   RODATA
53
54 #ifdef CONFIG_STACK_UNWIND
55   . = ALIGN(8);
56   .eh_frame : AT(ADDR(.eh_frame) - LOAD_OFFSET) {
57         __start_unwind = .;
58         *(.eh_frame)
59         __end_unwind = .;
60   }
61 #endif
62
63                                 /* Data */
64   .data : AT(ADDR(.data) - LOAD_OFFSET) {
65         *(.data)
66         CONSTRUCTORS
67         } :data
68
69   _edata = .;                   /* End of data section */
70
71   . = ALIGN(PAGE_SIZE);
72   . = ALIGN(CONFIG_X86_L1_CACHE_BYTES);
73   .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
74         *(.data.cacheline_aligned)
75   }
76   . = ALIGN(CONFIG_X86_INTERNODE_CACHE_BYTES);
77   .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
78         *(.data.read_mostly)
79   }
80
81 #define VSYSCALL_ADDR (-10*1024*1024)
82 #define VSYSCALL_PHYS_ADDR ((LOADADDR(.data.read_mostly) + SIZEOF(.data.read_mostly) + 4095) & ~(4095))
83 #define VSYSCALL_VIRT_ADDR ((ADDR(.data.read_mostly) + SIZEOF(.data.read_mostly) + 4095) & ~(4095))
84
85 #define VLOAD_OFFSET (VSYSCALL_ADDR - VSYSCALL_PHYS_ADDR)
86 #define VLOAD(x) (ADDR(x) - VLOAD_OFFSET)
87
88 #define VVIRT_OFFSET (VSYSCALL_ADDR - VSYSCALL_VIRT_ADDR)
89 #define VVIRT(x) (ADDR(x) - VVIRT_OFFSET)
90
91   . = VSYSCALL_ADDR;
92   .vsyscall_0 :  AT(VSYSCALL_PHYS_ADDR) { *(.vsyscall_0) } :user
93   __vsyscall_0 = VSYSCALL_VIRT_ADDR;
94
95   . = ALIGN(CONFIG_X86_L1_CACHE_BYTES);
96   .xtime_lock : AT(VLOAD(.xtime_lock)) { *(.xtime_lock) }
97   xtime_lock = VVIRT(.xtime_lock);
98
99   .vxtime : AT(VLOAD(.vxtime)) { *(.vxtime) }
100   vxtime = VVIRT(.vxtime);
101
102   .vgetcpu_mode : AT(VLOAD(.vgetcpu_mode)) { *(.vgetcpu_mode) }
103   vgetcpu_mode = VVIRT(.vgetcpu_mode);
104
105   .sys_tz : AT(VLOAD(.sys_tz)) { *(.sys_tz) }
106   sys_tz = VVIRT(.sys_tz);
107
108   .sysctl_vsyscall : AT(VLOAD(.sysctl_vsyscall)) { *(.sysctl_vsyscall) }
109   sysctl_vsyscall = VVIRT(.sysctl_vsyscall);
110
111   .xtime : AT(VLOAD(.xtime)) { *(.xtime) }
112   xtime = VVIRT(.xtime);
113
114   . = ALIGN(CONFIG_X86_L1_CACHE_BYTES);
115   .jiffies : AT(VLOAD(.jiffies)) { *(.jiffies) }
116   jiffies = VVIRT(.jiffies);
117
118   .vsyscall_1 ADDR(.vsyscall_0) + 1024: AT(VLOAD(.vsyscall_1)) { *(.vsyscall_1) }
119   .vsyscall_2 ADDR(.vsyscall_0) + 2048: AT(VLOAD(.vsyscall_2)) { *(.vsyscall_2) }
120   .vsyscall_3 ADDR(.vsyscall_0) + 3072: AT(VLOAD(.vsyscall_3)) { *(.vsyscall_3) }
121
122   . = VSYSCALL_VIRT_ADDR + 4096;
123
124 #undef VSYSCALL_ADDR
125 #undef VSYSCALL_PHYS_ADDR
126 #undef VSYSCALL_VIRT_ADDR
127 #undef VLOAD_OFFSET
128 #undef VLOAD
129 #undef VVIRT_OFFSET
130 #undef VVIRT
131
132   . = ALIGN(8192);              /* init_task */
133   .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
134         *(.data.init_task)
135   }:data.init
136
137   . = ALIGN(4096);
138   .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
139         *(.data.page_aligned)
140   }
141
142   /* might get freed after init */
143   . = ALIGN(4096);
144   __smp_alt_begin = .;
145   __smp_alt_instructions = .;
146   .smp_altinstructions : AT(ADDR(.smp_altinstructions) - LOAD_OFFSET) {
147         *(.smp_altinstructions)
148   }
149   __smp_alt_instructions_end = .;
150   . = ALIGN(8);
151   __smp_locks = .;
152   .smp_locks : AT(ADDR(.smp_locks) - LOAD_OFFSET) {
153         *(.smp_locks)
154   }
155   __smp_locks_end = .;
156   .smp_altinstr_replacement : AT(ADDR(.smp_altinstr_replacement) - LOAD_OFFSET) {
157         *(.smp_altinstr_replacement)
158   }
159   . = ALIGN(4096);
160   __smp_alt_end = .;
161
162   . = ALIGN(4096);              /* Init code and data */
163   __init_begin = .;
164   .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
165         _sinittext = .;
166         *(.init.text)
167         _einittext = .;
168   }
169   __initdata_begin = .;
170   .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) { *(.init.data) }
171   __initdata_end = .;
172   . = ALIGN(16);
173   __setup_start = .;
174   .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) { *(.init.setup) }
175   __setup_end = .;
176   __initcall_start = .;
177   .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
178         *(.initcall1.init) 
179         *(.initcall2.init) 
180         *(.initcall3.init) 
181         *(.initcall4.init) 
182         *(.initcall5.init) 
183         *(.initcall6.init) 
184         *(.initcall7.init)
185   }
186   __initcall_end = .;
187   __con_initcall_start = .;
188   .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
189         *(.con_initcall.init)
190   }
191   __con_initcall_end = .;
192   SECURITY_INIT
193   . = ALIGN(8);
194   __alt_instructions = .;
195   .altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) {
196         *(.altinstructions)
197   }
198   __alt_instructions_end = .; 
199   .altinstr_replacement : AT(ADDR(.altinstr_replacement) - LOAD_OFFSET) {
200         *(.altinstr_replacement)
201   }
202   /* .exit.text is discard at runtime, not link time, to deal with references
203      from .altinstructions and .eh_frame */
204   .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) { *(.exit.text) }
205   .exit.data : AT(ADDR(.exit.data) - LOAD_OFFSET) { *(.exit.data) }
206   . = ALIGN(4096);
207   __initramfs_start = .;
208   .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) { *(.init.ramfs) }
209   __initramfs_end = .;
210     . = ALIGN(CONFIG_X86_L1_CACHE_BYTES);
211   __per_cpu_start = .;
212   .data.percpu  : AT(ADDR(.data.percpu) - LOAD_OFFSET) { *(.data.percpu) }
213   __per_cpu_end = .;
214   . = ALIGN(4096);
215   __init_end = .;
216
217   . = ALIGN(4096);
218   __nosave_begin = .;
219   .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) { *(.data.nosave) }
220   . = ALIGN(4096);
221   __nosave_end = .;
222
223   __bss_start = .;              /* BSS */
224   .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
225         *(.bss.page_aligned)
226         *(.bss)
227         }
228   __bss_stop = .;
229
230   _end = . ;
231
232   /* Sections to be discarded */
233   /DISCARD/ : {
234         *(.exitcall.exit)
235 #ifndef CONFIG_UNWIND_INFO
236         *(.eh_frame)
237 #endif
238         }
239
240   STABS_DEBUG
241
242   DWARF_DEBUG
243 }