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