arch/powerpc/kernel/vmlinux.lds.S

   1 #ifdef CONFIG_PPC64
   2 #define PROVIDE32(x)    PROVIDE(__unused__##x)
   3 #else
   4 #define PROVIDE32(x)    PROVIDE(x)
   5 #endif
   6 #include <asm/page.h>
   7 #include <asm-generic/vmlinux.lds.h>
   8 #include <asm/cache.h>
   9 #include <asm/thread_info.h>
  10
  11 ENTRY(_stext)
  12
  13 PHDRS {
  14         kernel PT_LOAD FLAGS(7); /* RWX */
  15         notes PT_NOTE FLAGS(0);
  16         dummy PT_NOTE FLAGS(0);
  17
  18         /* binutils < 2.18 has a bug that makes it misbehave when taking an
  19            ELF file with all segments at load address 0 as input.  This
  20            happens when running "strip" on vmlinux, because of the AT() magic
  21            in this linker script.  People using GCC >= 4.2 won't run into
  22            this problem, because the "build-id" support will put some data
  23            into the "notes" segment (at a non-zero load address).
  24
  25            To work around this, we force some data into both the "dummy"
  26            segment and the kernel segment, so the dummy segment will get a
  27            non-zero load address.  It's not enough to always create the
  28            "notes" segment, since if nothing gets assigned to it, its load
  29            address will be zero.  */
  30 }
  31
  32 #ifdef CONFIG_PPC64
  33 OUTPUT_ARCH(powerpc:common64)
  34 jiffies = jiffies_64;
  35 #else
  36 OUTPUT_ARCH(powerpc:common)
  37 jiffies = jiffies_64 + 4;
  38 #endif
  39 SECTIONS
  40 {
  41         . = KERNELBASE;
  42
  43 /*
  44  * Text, read only data and other permanent read-only sections
  45  */
  46
  47         /* Text and gots */
  48         .text : AT(ADDR(.text) - LOAD_OFFSET) {
  49                 ALIGN_FUNCTION();
  50                 HEAD_TEXT
  51                 _text = .;
  52                 /* careful! __ftr_alt_* sections need to be close to .text */
  53                 *(.text .fixup __ftr_alt_* .ref.text)
  54                 SCHED_TEXT
  55                 LOCK_TEXT
  56                 KPROBES_TEXT
  57                 IRQENTRY_TEXT
  58
  59 #ifdef CONFIG_PPC32
  60                 *(.got1)
  61                 __got2_start = .;
  62                 *(.got2)
  63                 __got2_end = .;
  64 #endif /* CONFIG_PPC32 */
  65
  66         } :kernel
  67
  68         . = ALIGN(PAGE_SIZE);
  69         _etext = .;
  70         PROVIDE32 (etext = .);
  71
  72         /* Read-only data */
  73         RODATA
  74
  75         EXCEPTION_TABLE(0)
  76
  77         NOTES :kernel :notes
  78
  79         /* The dummy segment contents for the bug workaround mentioned above
  80            near PHDRS.  */
  81         .dummy : AT(ADDR(.dummy) - LOAD_OFFSET) {
  82                 LONG(0)
  83                 LONG(0)
  84                 LONG(0)
  85         } :kernel :dummy
  86
  87 /*
  88  * Init sections discarded at runtime
  89  */
  90         . = ALIGN(PAGE_SIZE);
  91         __init_begin = .;
  92         INIT_TEXT_SECTION(PAGE_SIZE) :kernel
  93
  94         /* .exit.text is discarded at runtime, not link time,
  95          * to deal with references from __bug_table
  96          */
  97         .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
  98                 EXIT_TEXT
  99         }
 100
 101         .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
 102                 INIT_DATA
 103                 __vtop_table_begin = .;
 104                 *(.vtop_fixup);
 105                 __vtop_table_end = .;
 106                 __ptov_table_begin = .;
 107                 *(.ptov_fixup);
 108                 __ptov_table_end = .;
 109 #ifdef CONFIG_PPC_ISERIES
 110                 __dt_strings_start = .;
 111                 *(.dt_strings);
 112                 __dt_strings_end = .;
 113 #endif
 114         }
 115
 116         .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
 117                 INIT_SETUP(16)
 118         }
 119
 120         .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
 121                 INIT_CALLS
 122         }
 123
 124         .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
 125                 CON_INITCALL
 126         }
 127
 128         SECURITY_INIT
 129
 130         . = ALIGN(8);
 131         __ftr_fixup : AT(ADDR(__ftr_fixup) - LOAD_OFFSET) {
 132                 __start___ftr_fixup = .;
 133                 *(__ftr_fixup)
 134                 __stop___ftr_fixup = .;
 135         }
 136         . = ALIGN(8);
 137         __mmu_ftr_fixup : AT(ADDR(__mmu_ftr_fixup) - LOAD_OFFSET) {
 138                 __start___mmu_ftr_fixup = .;
 139                 *(__mmu_ftr_fixup)
 140                 __stop___mmu_ftr_fixup = .;
 141         }
 142         . = ALIGN(8);
 143         __lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
 144                 __start___lwsync_fixup = .;
 145                 *(__lwsync_fixup)
 146                 __stop___lwsync_fixup = .;
 147         }
 148 #ifdef CONFIG_PPC64
 149         . = ALIGN(8);
 150         __fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
 151                 __start___fw_ftr_fixup = .;
 152                 *(__fw_ftr_fixup)
 153                 __stop___fw_ftr_fixup = .;
 154         }
 155 #endif
 156         .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
 157                 INIT_RAM_FS
 158         }
 159
 160         PERCPU(PAGE_SIZE)
 161
 162         . = ALIGN(8);
 163         .machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
 164                 __machine_desc_start = . ;
 165                 *(.machine.desc)
 166                 __machine_desc_end = . ;
 167         }
 168 #ifdef CONFIG_RELOCATABLE
 169         . = ALIGN(8);
 170         .dynsym : AT(ADDR(.dynsym) - LOAD_OFFSET) { *(.dynsym) }
 171         .dynstr : AT(ADDR(.dynstr) - LOAD_OFFSET) { *(.dynstr) }
 172         .dynamic : AT(ADDR(.dynamic) - LOAD_OFFSET)
 173         {
 174                 __dynamic_start = .;
 175                 *(.dynamic)
 176         }
 177         .hash : AT(ADDR(.hash) - LOAD_OFFSET) { *(.hash) }
 178         .interp : AT(ADDR(.interp) - LOAD_OFFSET) { *(.interp) }
 179         .rela.dyn : AT(ADDR(.rela.dyn) - LOAD_OFFSET)
 180         {
 181                 __rela_dyn_start = .;
 182                 *(.rela*)
 183         }
 184 #endif
 185
 186         /* freed after init ends here */
 187         . = ALIGN(PAGE_SIZE);
 188         __init_end = .;
 189
 190 /*
 191  * And now the various read/write data
 192  */
 193
 194         . = ALIGN(PAGE_SIZE);
 195         _sdata = .;
 196
 197 #ifdef CONFIG_PPC32
 198         .data : AT(ADDR(.data) - LOAD_OFFSET) {
 199                 DATA_DATA
 200                 *(.sdata)
 201                 *(.got.plt) *(.got)
 202         }
 203 #else
 204         .data : AT(ADDR(.data) - LOAD_OFFSET) {
 205                 DATA_DATA
 206                 *(.data.rel*)
 207                 *(.toc1)
 208                 *(.branch_lt)
 209         }
 210
 211         .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
 212                 *(.opd)
 213         }
 214
 215         .got : AT(ADDR(.got) - LOAD_OFFSET) {
 216                 __toc_start = .;
 217                 *(.got)
 218                 *(.toc)
 219         }
 220 #endif
 221
 222         /* The initial task and kernel stack */
 223         .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
 224                 INIT_TASK_DATA(THREAD_SIZE)
 225         }
 226
 227         .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
 228                 PAGE_ALIGNED_DATA(PAGE_SIZE)
 229         }
 230
 231         .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
 232                 CACHELINE_ALIGNED_DATA(L1_CACHE_BYTES)
 233         }
 234
 235         .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
 236                 READ_MOSTLY_DATA(L1_CACHE_BYTES)
 237         }
 238
 239         . = ALIGN(PAGE_SIZE);
 240         .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
 241                 NOSAVE_DATA
 242         }
 243
 244         . = ALIGN(PAGE_SIZE);
 245         _edata  =  .;
 246         PROVIDE32 (edata = .);
 247
 248 /*
 249  * And finally the bss
 250  */
 251
 252         BSS_SECTION(0, 0, 0)
 253
 254         . = ALIGN(PAGE_SIZE);
 255         _end = . ;
 256         PROVIDE32 (end = .);
 257
 258         /* Sections to be discarded. */
 259         DISCARDS
 260 }