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