root/arch/ia64/kernel/vmlinux.lds.S

/* [<][>][^][v][top][bottom][index][help] */ 
   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 
   3 #include <asm/cache.h>
   4 #include <asm/ptrace.h>
   5 #include <asm/pgtable.h>
   6 #include <asm/thread_info.h>
   7 
   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 
  15 PHDRS {
  16         code   PT_LOAD;
  17         percpu PT_LOAD;
  18         data   PT_LOAD;
  19         note   PT_NOTE;
  20         unwind 0x70000001; /* PT_IA_64_UNWIND, but ld doesn't match the name */
  21 }
  22 
  23 SECTIONS {
  24         /*
  25          * unwind exit sections must be discarded before
  26          * the rest of the sections get included.
  27          */
  28         /DISCARD/ : {
  29                 *(.IA_64.unwind.exit.text)
  30                 *(.IA_64.unwind_info.exit.text)
  31                 *(.comment)
  32                 *(.note)
  33         }
  34 
  35         v = PAGE_OFFSET; /* this symbol is here to make debugging easier... */
  36         phys_start = _start - LOAD_OFFSET;
  37 
  38         code : {
  39         } :code
  40         . = KERNEL_START;
  41 
  42         _text = .;
  43         _stext = .;
  44 
  45         .text : AT(ADDR(.text) - LOAD_OFFSET) {
  46                 __start_ivt_text = .;
  47                 *(.text..ivt)
  48                 __end_ivt_text = .;
  49                 TEXT_TEXT
  50                 SCHED_TEXT
  51                 CPUIDLE_TEXT
  52                 LOCK_TEXT
  53                 KPROBES_TEXT
  54                 *(.gnu.linkonce.t*)
  55         }
  56 
  57         .text2 : AT(ADDR(.text2) - LOAD_OFFSET) {
  58                 *(.text2)
  59         }
  60 
  61 #ifdef CONFIG_SMP
  62         .text..lock : AT(ADDR(.text..lock) - LOAD_OFFSET) {
  63                 *(.text..lock)
  64         }
  65 #endif
  66         _etext = .;
  67 
  68         /*
  69          * Read-only data
  70          */
  71         NOTES :code :note       /* put .notes in text and mark in PT_NOTE  */
  72         code_continues : {
  73         } : code               /* switch back to regular program...  */
  74 
  75         EXCEPTION_TABLE(16)
  76 
  77         /* MCA table */
  78         . = ALIGN(16);
  79         __mca_table : AT(ADDR(__mca_table) - LOAD_OFFSET) {
  80                 __start___mca_table = .;
  81                 *(__mca_table)
  82                 __stop___mca_table = .;
  83         }
  84 
  85         .data..patch.phys_stack_reg : AT(ADDR(.data..patch.phys_stack_reg) - LOAD_OFFSET) {
  86                 __start___phys_stack_reg_patchlist = .;
  87                 *(.data..patch.phys_stack_reg)
  88                 __end___phys_stack_reg_patchlist = .;
  89         }
  90 
  91         /*
  92          * Global data
  93          */
  94         _data = .;
  95 
  96         /* Unwind info & table: */
  97         . = ALIGN(8);
  98         .IA_64.unwind_info : AT(ADDR(.IA_64.unwind_info) - LOAD_OFFSET) {
  99                 *(.IA_64.unwind_info*)
 100         }
 101         .IA_64.unwind : AT(ADDR(.IA_64.unwind) - LOAD_OFFSET) {
 102                 __start_unwind = .;
 103                 *(.IA_64.unwind*)
 104                 __end_unwind = .;
 105         } :code :unwind
 106         code_continues2 : {
 107         } : code
 108 
 109         RODATA
 110 
 111         .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
 112                 __start_opd = .;
 113                 *(.opd)
 114                 __end_opd = .;
 115         }
 116 
 117         /*
 118          * Initialization code and data:
 119          */
 120         . = ALIGN(PAGE_SIZE);
 121         __init_begin = .;
 122 
 123         INIT_TEXT_SECTION(PAGE_SIZE)
 124         INIT_DATA_SECTION(16)
 125 
 126         .data..patch.vtop : AT(ADDR(.data..patch.vtop) - LOAD_OFFSET) {
 127                 __start___vtop_patchlist = .;
 128                 *(.data..patch.vtop)
 129                 __end___vtop_patchlist = .;
 130         }
 131 
 132         .data..patch.rse : AT(ADDR(.data..patch.rse) - LOAD_OFFSET) {
 133                 __start___rse_patchlist = .;
 134                 *(.data..patch.rse)
 135                 __end___rse_patchlist = .;
 136         }
 137 
 138         .data..patch.mckinley_e9 : AT(ADDR(.data..patch.mckinley_e9) - LOAD_OFFSET) {
 139                 __start___mckinley_e9_bundles = .;
 140                 *(.data..patch.mckinley_e9)
 141                 __end___mckinley_e9_bundles = .;
 142         }
 143 
 144 #ifdef  CONFIG_SMP
 145         . = ALIGN(PERCPU_PAGE_SIZE);
 146         __cpu0_per_cpu = .;
 147         . = . + PERCPU_PAGE_SIZE;   /* cpu0 per-cpu space */
 148 #endif
 149 
 150         . = ALIGN(PAGE_SIZE);
 151         __init_end = .;
 152 
 153         .data..page_aligned : AT(ADDR(.data..page_aligned) - LOAD_OFFSET) {
 154                 PAGE_ALIGNED_DATA(PAGE_SIZE)
 155                 . = ALIGN(PAGE_SIZE);
 156                 __start_gate_section = .;
 157                 *(.data..gate)
 158                 __stop_gate_section = .;
 159         }
 160         /*
 161          * make sure the gate page doesn't expose
 162          * kernel data
 163          */
 164         . = ALIGN(PAGE_SIZE);
 165 
 166         /* Per-cpu data: */
 167         . = ALIGN(PERCPU_PAGE_SIZE);
 168         PERCPU_VADDR(SMP_CACHE_BYTES, PERCPU_ADDR, :percpu)
 169         __phys_per_cpu_start = __per_cpu_load;
 170         /*
 171          * ensure percpu data fits
 172          * into percpu page size
 173          */
 174         . = __phys_per_cpu_start + PERCPU_PAGE_SIZE;
 175 
 176         data : {
 177         } :data
 178         .data : AT(ADDR(.data) - LOAD_OFFSET) {
 179                 _sdata  =  .;
 180                 INIT_TASK_DATA(PAGE_SIZE)
 181                 CACHELINE_ALIGNED_DATA(SMP_CACHE_BYTES)
 182                 READ_MOSTLY_DATA(SMP_CACHE_BYTES)
 183                 DATA_DATA
 184                 *(.data1)
 185                 *(.gnu.linkonce.d*)
 186                 CONSTRUCTORS
 187         }
 188 
 189         BUG_TABLE
 190 
 191         . = ALIGN(16);  /* gp must be 16-byte aligned for exc. table */
 192         .got : AT(ADDR(.got) - LOAD_OFFSET) {
 193                 *(.got.plt)
 194                 *(.got)
 195         }
 196         __gp = ADDR(.got) + 0x200000;
 197 
 198         /*
 199          * We want the small data sections together,
 200          * so single-instruction offsets can access
 201          * them all, and initialized data all before
 202          * uninitialized, so we can shorten the
 203          * on-disk segment size.
 204          */
 205         .sdata : AT(ADDR(.sdata) - LOAD_OFFSET) {
 206                 *(.sdata)
 207                 *(.sdata1)
 208                 *(.srdata)
 209         }
 210         _edata  =  .;
 211 
 212         BSS_SECTION(0, 0, 0)
 213 
 214         _end = .;
 215 
 216         code : {
 217         } :code
 218 
 219         STABS_DEBUG
 220         DWARF_DEBUG
 221 
 222         /* Default discards */
 223         DISCARDS
 224 }
/* [<][>][^][v][top][bottom][index][help] */