1 2#include <asm/cache.h> 3#include <asm/ptrace.h> 4#include <asm/system.h> 5#include <asm/pgtable.h> 6 7#include <asm-generic/vmlinux.lds.h> 8 9#define IVT_TEXT \ 10 VMLINUX_SYMBOL(__start_ivt_text) = .; \ 11 *(.text.ivt) \ 12 VMLINUX_SYMBOL(__end_ivt_text) = .; 13 14OUTPUT_FORMAT("elf64-ia64-little") 15OUTPUT_ARCH(ia64) 16ENTRY(phys_start) 17jiffies = jiffies_64; 18PHDRS { 19 code PT_LOAD; 20 percpu PT_LOAD; 21 data PT_LOAD; 22 note PT_NOTE; 23 unwind 0x70000001; /* PT_IA_64_UNWIND, but ld doesn't match the name */ 24} 25SECTIONS 26{ 27 /* Sections to be discarded */ 28 /DISCARD/ : { 29 EXIT_TEXT 30 EXIT_DATA 31 *(.exitcall.exit) 32 *(.IA_64.unwind.exit.text) 33 *(.IA_64.unwind_info.exit.text) 34 } 35 36 v = PAGE_OFFSET; /* this symbol is here to make debugging easier... */ 37 phys_start = _start - LOAD_OFFSET; 38 39 code : { } :code 40 . = KERNEL_START; 41 42 _text = .; 43 _stext = .; 44 45 .text : AT(ADDR(.text) - LOAD_OFFSET) 46 { 47 IVT_TEXT 48 TEXT_TEXT 49 SCHED_TEXT 50 LOCK_TEXT 51 KPROBES_TEXT 52 *(.gnu.linkonce.t*) 53 } 54 .text.head : AT(ADDR(.text.head) - LOAD_OFFSET) 55 { *(.text.head) } 56 .text2 : AT(ADDR(.text2) - LOAD_OFFSET) 57 { *(.text2) } 58#ifdef CONFIG_SMP 59 .text.lock : AT(ADDR(.text.lock) - LOAD_OFFSET) 60 { *(.text.lock) } 61#endif 62 _etext = .; 63 64 /* Read-only data */ 65 66 NOTES :code :note /* put .notes in text and mark in PT_NOTE */ 67 code_continues : {} :code /* switch back to regular program... */ 68 69 /* Exception table */ 70 . = ALIGN(16); 71 __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) 72 { 73 __start___ex_table = .; 74 *(__ex_table) 75 __stop___ex_table = .; 76 } 77 78 /* MCA table */ 79 . = ALIGN(16); 80 __mca_table : AT(ADDR(__mca_table) - LOAD_OFFSET) 81 { 82 __start___mca_table = .; 83 *(__mca_table) 84 __stop___mca_table = .; 85 } 86 87 .data.patch.phys_stack_reg : AT(ADDR(.data.patch.phys_stack_reg) - LOAD_OFFSET) 88 { 89 __start___phys_stack_reg_patchlist = .; 90 *(.data.patch.phys_stack_reg) 91 __end___phys_stack_reg_patchlist = .; 92 } 93 94 /* Global data */ 95 _data = .; 96 97 /* Unwind info & table: */ 98 . = ALIGN(8); 99 .IA_64.unwind_info : AT(ADDR(.IA_64.unwind_info) - LOAD_OFFSET) 100 { *(.IA_64.unwind_info*) } 101 .IA_64.unwind : AT(ADDR(.IA_64.unwind) - LOAD_OFFSET) 102 { 103 __start_unwind = .; 104 *(.IA_64.unwind*) 105 __end_unwind = .; 106 } :code :unwind 107 code_continues2 : {} : code 108 109 RODATA 110 111 .opd : AT(ADDR(.opd) - LOAD_OFFSET) 112 { *(.opd) } 113 114 /* Initialization code and data: */ 115 116 . = ALIGN(PAGE_SIZE); 117 __init_begin = .; 118 .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) 119 { 120 _sinittext = .; 121 INIT_TEXT 122 _einittext = .; 123 } 124 125 .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) 126 { INIT_DATA } 127 128#ifdef CONFIG_BLK_DEV_INITRD 129 .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) 130 { 131 __initramfs_start = .; 132 *(.init.ramfs) 133 __initramfs_end = .; 134 } 135#endif 136 137 . = ALIGN(16); 138 .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) 139 { 140 __setup_start = .; 141 *(.init.setup) 142 __setup_end = .; 143 } 144 .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) 145 { 146 __initcall_start = .; 147 INITCALLS 148 __initcall_end = .; 149 } 150 151 .data.patch.vtop : AT(ADDR(.data.patch.vtop) - LOAD_OFFSET) 152 { 153 __start___vtop_patchlist = .; 154 *(.data.patch.vtop) 155 __end___vtop_patchlist = .; 156 } 157 158 .data.patch.rse : AT(ADDR(.data.patch.rse) - LOAD_OFFSET) 159 { 160 __start___rse_patchlist = .; 161 *(.data.patch.rse) 162 __end___rse_patchlist = .; 163 } 164 165 .data.patch.mckinley_e9 : AT(ADDR(.data.patch.mckinley_e9) - LOAD_OFFSET) 166 { 167 __start___mckinley_e9_bundles = .; 168 *(.data.patch.mckinley_e9) 169 __end___mckinley_e9_bundles = .; 170 } 171 172#if defined(CONFIG_IA64_GENERIC) 173 /* Machine Vector */ 174 . = ALIGN(16); 175 .machvec : AT(ADDR(.machvec) - LOAD_OFFSET) 176 { 177 machvec_start = .; 178 *(.machvec) 179 machvec_end = .; 180 } 181#endif 182 183 . = ALIGN(8); 184 __con_initcall_start = .; 185 .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) 186 { *(.con_initcall.init) } 187 __con_initcall_end = .; 188 __security_initcall_start = .; 189 .security_initcall.init : AT(ADDR(.security_initcall.init) - LOAD_OFFSET) 190 { *(.security_initcall.init) } 191 __security_initcall_end = .; 192 . = ALIGN(PAGE_SIZE); 193 __init_end = .; 194 195 /* The initial task and kernel stack */ 196 .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) 197 { *(.data.init_task) } 198 199 .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) 200 { *(__special_page_section) 201 __start_gate_section = .; 202 *(.data.gate) 203 __stop_gate_section = .; 204 } 205 . = ALIGN(PAGE_SIZE); /* make sure the gate page doesn't expose 206 * kernel data 207 */ 208 209 .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) 210 { *(.data.read_mostly) } 211 212 .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) 213 { *(.data.cacheline_aligned) } 214 215 /* Per-cpu data: */ 216 percpu : { } :percpu 217 . = ALIGN(PERCPU_PAGE_SIZE); 218 __phys_per_cpu_start = .; 219 .data.percpu PERCPU_ADDR : AT(__phys_per_cpu_start - LOAD_OFFSET) 220 { 221 __per_cpu_start = .; 222 *(.data.percpu) 223 *(.data.percpu.shared_aligned) 224 __per_cpu_end = .; 225 } 226 . = __phys_per_cpu_start + PERCPU_PAGE_SIZE; /* ensure percpu data fits 227 * into percpu page size 228 */ 229 230 data : { } :data 231 .data : AT(ADDR(.data) - LOAD_OFFSET) 232 { 233#ifdef CONFIG_SMP 234 . = ALIGN(PERCPU_PAGE_SIZE); 235 __cpu0_per_cpu = .; 236 . = . + PERCPU_PAGE_SIZE; /* cpu0 per-cpu space */ 237#endif 238 DATA_DATA 239 *(.data1) 240 *(.gnu.linkonce.d*) 241 CONSTRUCTORS 242 } 243 244 . = ALIGN(16); /* gp must be 16-byte aligned for exc. table */ 245 .got : AT(ADDR(.got) - LOAD_OFFSET) 246 { *(.got.plt) *(.got) } 247 __gp = ADDR(.got) + 0x200000; 248 /* We want the small data sections together, so single-instruction offsets 249 can access them all, and initialized data all before uninitialized, so 250 we can shorten the on-disk segment size. */ 251 .sdata : AT(ADDR(.sdata) - LOAD_OFFSET) 252 { *(.sdata) *(.sdata1) *(.srdata) } 253 _edata = .; 254 __bss_start = .; 255 .sbss : AT(ADDR(.sbss) - LOAD_OFFSET) 256 { *(.sbss) *(.scommon) } 257 .bss : AT(ADDR(.bss) - LOAD_OFFSET) 258 { *(.bss) *(COMMON) } 259 __bss_stop = .; 260 261 _end = .; 262 263 code : { } :code 264 /* Stabs debugging sections. */ 265 .stab 0 : { *(.stab) } 266 .stabstr 0 : { *(.stabstr) } 267 .stab.excl 0 : { *(.stab.excl) } 268 .stab.exclstr 0 : { *(.stab.exclstr) } 269 .stab.index 0 : { *(.stab.index) } 270 .stab.indexstr 0 : { *(.stab.indexstr) } 271 /* DWARF debug sections. 272 Symbols in the DWARF debugging sections are relative to the beginning 273 of the section so we begin them at 0. */ 274 /* DWARF 1 */ 275 .debug 0 : { *(.debug) } 276 .line 0 : { *(.line) } 277 /* GNU DWARF 1 extensions */ 278 .debug_srcinfo 0 : { *(.debug_srcinfo) } 279 .debug_sfnames 0 : { *(.debug_sfnames) } 280 /* DWARF 1.1 and DWARF 2 */ 281 .debug_aranges 0 : { *(.debug_aranges) } 282 .debug_pubnames 0 : { *(.debug_pubnames) } 283 /* DWARF 2 */ 284 .debug_info 0 : { *(.debug_info) } 285 .debug_abbrev 0 : { *(.debug_abbrev) } 286 .debug_line 0 : { *(.debug_line) } 287 .debug_frame 0 : { *(.debug_frame) } 288 .debug_str 0 : { *(.debug_str) } 289 .debug_loc 0 : { *(.debug_loc) } 290 .debug_macinfo 0 : { *(.debug_macinfo) } 291 /* SGI/MIPS DWARF 2 extensions */ 292 .debug_weaknames 0 : { *(.debug_weaknames) } 293 .debug_funcnames 0 : { *(.debug_funcnames) } 294 .debug_typenames 0 : { *(.debug_typenames) } 295 .debug_varnames 0 : { *(.debug_varnames) } 296 /* These must appear regardless of . */ 297 /DISCARD/ : { *(.comment) } 298 /DISCARD/ : { *(.note) } 299} 300