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         . = KERNELBASE;
  41
  42 /*
  43  * Text, read only data and other permanent read-only sections
  44  */
  45
  46         /* Text and gots */
  47         .text : AT(ADDR(.text) - LOAD_OFFSET) {
  48                 ALIGN_FUNCTION();
  49                 HEAD_TEXT
  50                 _text = .;
  51                 /* careful! __ftr_alt_* sections need to be close to .text */
  52                 *(.text .fixup __ftr_alt_* .ref.text)
  53                 SCHED_TEXT
  54                 LOCK_TEXT
  55                 KPROBES_TEXT
  56                 IRQENTRY_TEXT
  57
  58 #ifdef CONFIG_PPC32
  59                 *(.got1)
  60                 __got2_start = .;
  61                 *(.got2)
  62                 __got2_end = .;
  63 #endif /* CONFIG_PPC32 */
  64
  65         } :kernel
  66
  67         . = ALIGN(PAGE_SIZE);
  68         _etext = .;
  69         PROVIDE32 (etext = .);
  70
  71         /* Read-only data */
  72         RODATA
  73
  74         /* Exception & bug tables */
  75         __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
  76                 __start___ex_table = .;
  77                 *(__ex_table)
  78                 __stop___ex_table = .;
  79         }
  80
  81         NOTES :kernel :notes
  82
  83         /* The dummy segment contents for the bug workaround mentioned above
  84            near PHDRS.  */
  85         .dummy : AT(ADDR(.dummy) - LOAD_OFFSET) {
  86                 LONG(0)
  87                 LONG(0)
  88                 LONG(0)
  89         } :kernel :dummy
  90
  91 /*
  92  * Init sections discarded at runtime
  93  */
  94         . = ALIGN(PAGE_SIZE);
  95         __init_begin = .;
  96
  97         .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
  98                 _sinittext = .;
  99                 INIT_TEXT
 100                 _einittext = .;
 101         } :kernel
 102
 103         /* .exit.text is discarded at runtime, not link time,
 104          * to deal with references from __bug_table
 105          */
 106         .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
 107                 EXIT_TEXT
 108         }
 109
 110         .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
 111                 INIT_DATA
 112                 __vtop_table_begin = .;
 113                 *(.vtop_fixup);
 114                 __vtop_table_end = .;
 115                 __ptov_table_begin = .;
 116                 *(.ptov_fixup);
 117                 __ptov_table_end = .;
 118 #ifdef CONFIG_PPC_ISERIES
 119                 __dt_strings_start = .;
 120                 *(.dt_strings);
 121                 __dt_strings_end = .;
 122 #endif
 123         }
 124
 125         . = ALIGN(16);
 126         .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
 127                 __setup_start = .;
 128                 *(.init.setup)
 129                 __setup_end = .;
 130         }
 131
 132         .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
 133                 __initcall_start = .;
 134                 INITCALLS
 135                 __initcall_end = .;
 136                 }
 137
 138         .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
 139                 __con_initcall_start = .;
 140                 *(.con_initcall.init)
 141                 __con_initcall_end = .;
 142         }
 143
 144         SECURITY_INIT
 145
 146         . = ALIGN(8);
 147         __ftr_fixup : AT(ADDR(__ftr_fixup) - LOAD_OFFSET) {
 148                 __start___ftr_fixup = .;
 149                 *(__ftr_fixup)
 150                 __stop___ftr_fixup = .;
 151         }
 152         . = ALIGN(8);
 153         __mmu_ftr_fixup : AT(ADDR(__mmu_ftr_fixup) - LOAD_OFFSET) {
 154                 __start___mmu_ftr_fixup = .;
 155                 *(__mmu_ftr_fixup)
 156                 __stop___mmu_ftr_fixup = .;
 157         }
 158         . = ALIGN(8);
 159         __lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
 160                 __start___lwsync_fixup = .;
 161                 *(__lwsync_fixup)
 162                 __stop___lwsync_fixup = .;
 163         }
 164 #ifdef CONFIG_PPC64
 165         . = ALIGN(8);
 166         __fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
 167                 __start___fw_ftr_fixup = .;
 168                 *(__fw_ftr_fixup)
 169                 __stop___fw_ftr_fixup = .;
 170         }
 171 #endif
 172 #ifdef CONFIG_BLK_DEV_INITRD
 173         . = ALIGN(PAGE_SIZE);
 174         .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
 175                 __initramfs_start = .;
 176                 *(.init.ramfs)
 177                 __initramfs_end = .;
 178         }
 179 #endif
 180         PERCPU(PAGE_SIZE)
 181
 182         . = ALIGN(8);
 183         .machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
 184                 __machine_desc_start = . ;
 185                 *(.machine.desc)
 186                 __machine_desc_end = . ;
 187         }
 188 #ifdef CONFIG_RELOCATABLE
 189         . = ALIGN(8);
 190         .dynsym : AT(ADDR(.dynsym) - LOAD_OFFSET) { *(.dynsym) }
 191         .dynstr : AT(ADDR(.dynstr) - LOAD_OFFSET) { *(.dynstr) }
 192         .dynamic : AT(ADDR(.dynamic) - LOAD_OFFSET)
 193         {
 194                 __dynamic_start = .;
 195                 *(.dynamic)
 196         }
 197         .hash : AT(ADDR(.hash) - LOAD_OFFSET) { *(.hash) }
 198         .interp : AT(ADDR(.interp) - LOAD_OFFSET) { *(.interp) }
 199         .rela.dyn : AT(ADDR(.rela.dyn) - LOAD_OFFSET)
 200         {
 201                 __rela_dyn_start = .;
 202                 *(.rela*)
 203         }
 204 #endif
 205
 206         /* freed after init ends here */
 207         . = ALIGN(PAGE_SIZE);
 208         __init_end = .;
 209
 210 /*
 211  * And now the various read/write data
 212  */
 213
 214         . = ALIGN(PAGE_SIZE);
 215         _sdata = .;
 216
 217 #ifdef CONFIG_PPC32
 218         .data : AT(ADDR(.data) - LOAD_OFFSET) {
 219                 DATA_DATA
 220                 *(.sdata)
 221                 *(.got.plt) *(.got)
 222         }
 223 #else
 224         .data : AT(ADDR(.data) - LOAD_OFFSET) {
 225                 DATA_DATA
 226                 *(.data.rel*)
 227                 *(.toc1)
 228                 *(.branch_lt)
 229         }
 230
 231         .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
 232                 *(.opd)
 233         }
 234
 235         .got : AT(ADDR(.got) - LOAD_OFFSET) {
 236                 __toc_start = .;
 237                 *(.got)
 238                 *(.toc)
 239         }
 240 #endif
 241
 242         /* The initial task and kernel stack */
 243 #ifdef CONFIG_PPC32
 244         . = ALIGN(8192);
 245 #else
 246         . = ALIGN(16384);
 247 #endif
 248         .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
 249                 *(.data.init_task)
 250         }
 251
 252         . = ALIGN(PAGE_SIZE);
 253         .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
 254                 *(.data.page_aligned)
 255         }
 256
 257         . = ALIGN(L1_CACHE_BYTES);
 258         .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
 259                 *(.data.cacheline_aligned)
 260         }
 261
 262         . = ALIGN(L1_CACHE_BYTES);
 263         .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
 264                 *(.data.read_mostly)
 265         }
 266
 267         . = ALIGN(PAGE_SIZE);
 268         .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
 269                 __nosave_begin = .;
 270                 *(.data.nosave)
 271                 . = ALIGN(PAGE_SIZE);
 272                 __nosave_end = .;
 273         }
 274
 275         . = ALIGN(PAGE_SIZE);
 276         _edata  =  .;
 277         PROVIDE32 (edata = .);
 278
 279 /*
 280  * And finally the bss
 281  */
 282
 283         .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
 284                 __bss_start = .;
 285                 *(.sbss) *(.scommon)
 286                 *(.dynbss)
 287                 *(.bss)
 288                 *(COMMON)
 289                 __bss_stop = .;
 290         }
 291
 292         . = ALIGN(PAGE_SIZE);
 293         _end = . ;
 294         PROVIDE32 (end = .);
 295
 296         /* Sections to be discarded. */
 297         DISCARDS
 298 }