arch/ia64/vmlinux.lds.S

   1 #include <linux/config.h>
   2
   3 #include <asm/cache.h>
   4 #include <asm/ptrace.h>
   5 #include <asm/system.h>
   6
   7 #define LOAD_OFFSET PAGE_OFFSET
   8 #include <asm-generic/vmlinux.lds.h>
   9
  10 OUTPUT_FORMAT("elf64-ia64-little")
  11 OUTPUT_ARCH(ia64)
  12 ENTRY(phys_start)
  13 jiffies = jiffies_64;
  14 SECTIONS
  15 {
  16   /* Sections to be discarded */
  17   /DISCARD/ : {
  18         *(.exit.text)
  19         *(.exit.data)
  20         *(.exitcall.exit)
  21         *(.IA_64.unwind.exit.text)
  22         *(.IA_64.unwind_info.exit.text)
  23         }
  24
  25   v = PAGE_OFFSET;      /* this symbol is here to make debugging easier... */
  26   phys_start = _start - PAGE_OFFSET;
  27
  28   . = KERNEL_START;
  29
  30   _text = .;
  31   _stext = .;
  32
  33   .text : AT(ADDR(.text) - PAGE_OFFSET)
  34     {
  35         *(.text.ivt)
  36         *(.text)
  37     }
  38   .text2 : AT(ADDR(.text2) - PAGE_OFFSET)
  39         { *(.text2) }
  40 #ifdef CONFIG_SMP
  41   .text.lock : AT(ADDR(.text.lock) - PAGE_OFFSET)
  42         { *(.text.lock) }
  43 #endif
  44   _etext = .;
  45
  46   /* Read-only data */
  47
  48   /* Exception table */
  49   . = ALIGN(16);
  50   __ex_table : AT(ADDR(__ex_table) - PAGE_OFFSET)
  51         {
  52           __start___ex_table = .;
  53           *(__ex_table)
  54           __stop___ex_table = .;
  55         }
  56
  57   __mckinley_e9_bundles : AT(ADDR(__mckinley_e9_bundles) - PAGE_OFFSET)
  58         {
  59           __start___mckinley_e9_bundles = .;
  60           *(__mckinley_e9_bundles)
  61           __end___mckinley_e9_bundles = .;
  62         }
  63
  64   /* Global data */
  65   _data = .;
  66
  67 #if defined(CONFIG_IA64_GENERIC)
  68   /* Machine Vector */
  69   . = ALIGN(16);
  70   .machvec : AT(ADDR(.machvec) - PAGE_OFFSET)
  71         {
  72           machvec_start = .;
  73           *(.machvec)
  74           machvec_end = .;
  75         }
  76 #endif
  77
  78   /* Unwind info & table: */
  79   . = ALIGN(8);
  80   .IA_64.unwind_info : AT(ADDR(.IA_64.unwind_info) - PAGE_OFFSET)
  81         { *(.IA_64.unwind_info*) }
  82   .IA_64.unwind : AT(ADDR(.IA_64.unwind) - PAGE_OFFSET)
  83         {
  84           ia64_unw_start = .;
  85           *(.IA_64.unwind*)
  86           ia64_unw_end = .;
  87         }
  88
  89   RODATA
  90
  91   .opd : AT(ADDR(.opd) - PAGE_OFFSET)
  92         { *(.opd) }
  93
  94   /* Initialization code and data: */
  95
  96   . = ALIGN(PAGE_SIZE);
  97   __init_begin = .;
  98   .init.text : AT(ADDR(.init.text) - PAGE_OFFSET)
  99         {
 100           _sinittext = .;
 101           *(.init.text)
 102           _einittext = .;
 103         }
 104
 105   .init.data : AT(ADDR(.init.data) - PAGE_OFFSET)
 106         { *(.init.data) }
 107
 108   .init.ramfs : AT(ADDR(.init.ramfs) - PAGE_OFFSET)
 109         {
 110           __initramfs_start = .;
 111           *(.init.ramfs)
 112           __initramfs_end = .;
 113         }
 114
 115    . = ALIGN(16);
 116   .init.setup : AT(ADDR(.init.setup) - PAGE_OFFSET)
 117         {
 118           __setup_start = .;
 119           *(.init.setup)
 120           __setup_end = .;
 121         }
 122   __param : AT(ADDR(__param) - PAGE_OFFSET)
 123         {
 124           __start___param = .;
 125           *(__param)
 126           __stop___param = .;
 127         }
 128   .initcall.init : AT(ADDR(.initcall.init) - PAGE_OFFSET)
 129         {
 130           __initcall_start = .;
 131           *(.initcall1.init)
 132           *(.initcall2.init)
 133           *(.initcall3.init)
 134           *(.initcall4.init)
 135           *(.initcall5.init)
 136           *(.initcall6.init)
 137           *(.initcall7.init)
 138           __initcall_end = .;
 139         }
 140    __con_initcall_start = .;
 141   .con_initcall.init : AT(ADDR(.con_initcall.init) - PAGE_OFFSET)
 142         { *(.con_initcall.init) }
 143   __con_initcall_end = .;
 144   . = ALIGN(PAGE_SIZE);
 145   __init_end = .;
 146
 147   /* The initial task and kernel stack */
 148   .data.init_task : AT(ADDR(.data.init_task) - PAGE_OFFSET)
 149         { *(.data.init_task) }
 150
 151   .data.page_aligned : AT(ADDR(.data.page_aligned) - PAGE_OFFSET)
 152         { *(__special_page_section)
 153           __start_gate_section = .;
 154           *(.text.gate)
 155           __stop_gate_section = .;
 156         }
 157
 158   . = ALIGN(SMP_CACHE_BYTES);
 159   .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - PAGE_OFFSET)
 160         { *(.data.cacheline_aligned) }
 161
 162   /* Per-cpu data: */
 163   . = ALIGN(PERCPU_PAGE_SIZE);
 164   __phys_per_cpu_start = .;
 165   .data.percpu PERCPU_ADDR : AT(__phys_per_cpu_start - PAGE_OFFSET)
 166         {
 167                 __per_cpu_start = .;
 168                 *(.data.percpu)
 169                 __per_cpu_end = .;
 170         }
 171   . = __phys_per_cpu_start + PERCPU_PAGE_SIZE;  /* ensure percpu data fits into percpu page size */
 172
 173   .data : AT(ADDR(.data) - PAGE_OFFSET)
 174         { *(.data) *(.gnu.linkonce.d*) CONSTRUCTORS }
 175
 176   . = ALIGN(16);
 177   __gp = . + 0x200000;  /* gp must be 16-byte aligned for exc. table */
 178
 179   .got : AT(ADDR(.got) - PAGE_OFFSET)
 180         { *(.got.plt) *(.got) }
 181   /* We want the small data sections together, so single-instruction offsets
 182      can access them all, and initialized data all before uninitialized, so
 183      we can shorten the on-disk segment size.  */
 184   .sdata : AT(ADDR(.sdata) - PAGE_OFFSET)
 185         { *(.sdata) }
 186   _edata  =  .;
 187   _bss = .;
 188   .sbss : AT(ADDR(.sbss) - PAGE_OFFSET)
 189         { *(.sbss) *(.scommon) }
 190   .bss : AT(ADDR(.bss) - PAGE_OFFSET)
 191         { *(.bss) *(COMMON) }
 192
 193   _end = .;
 194
 195   /* Stabs debugging sections.  */
 196   .stab 0 : { *(.stab) }
 197   .stabstr 0 : { *(.stabstr) }
 198   .stab.excl 0 : { *(.stab.excl) }
 199   .stab.exclstr 0 : { *(.stab.exclstr) }
 200   .stab.index 0 : { *(.stab.index) }
 201   .stab.indexstr 0 : { *(.stab.indexstr) }
 202   /* DWARF debug sections.
 203      Symbols in the DWARF debugging sections are relative to the beginning
 204      of the section so we begin them at 0.  */
 205   /* DWARF 1 */
 206   .debug          0 : { *(.debug) }
 207   .line           0 : { *(.line) }
 208   /* GNU DWARF 1 extensions */
 209   .debug_srcinfo  0 : { *(.debug_srcinfo) }
 210   .debug_sfnames  0 : { *(.debug_sfnames) }
 211   /* DWARF 1.1 and DWARF 2 */
 212   .debug_aranges  0 : { *(.debug_aranges) }
 213   .debug_pubnames 0 : { *(.debug_pubnames) }
 214   /* DWARF 2 */
 215   .debug_info     0 : { *(.debug_info) }
 216   .debug_abbrev   0 : { *(.debug_abbrev) }
 217   .debug_line     0 : { *(.debug_line) }
 218   .debug_frame    0 : { *(.debug_frame) }
 219   .debug_str      0 : { *(.debug_str) }
 220   .debug_loc      0 : { *(.debug_loc) }
 221   .debug_macinfo  0 : { *(.debug_macinfo) }
 222   /* SGI/MIPS DWARF 2 extensions */
 223   .debug_weaknames 0 : { *(.debug_weaknames) }
 224   .debug_funcnames 0 : { *(.debug_funcnames) }
 225   .debug_typenames 0 : { *(.debug_typenames) }
 226   .debug_varnames  0 : { *(.debug_varnames) }
 227   /* These must appear regardless of  .  */
 228   /* Discard them for now since Intel SoftSDV cannot handle them.
 229   .comment 0 : { *(.comment) }
 230   .note 0 : { *(.note) }
 231   */
 232   /DISCARD/ : { *(.comment) }
 233   /DISCARD/ : { *(.note) }
 234 }