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         }
 110
 111         .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
 112                 INIT_SETUP(16)
 113         }
 114
 115         .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
 116                 INIT_CALLS
 117         }
 118
 119         .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
 120                 CON_INITCALL
 121         }
 122
 123         SECURITY_INIT
 124
 125         . = ALIGN(8);
 126         __ftr_fixup : AT(ADDR(__ftr_fixup) - LOAD_OFFSET) {
 127                 __start___ftr_fixup = .;
 128                 *(__ftr_fixup)
 129                 __stop___ftr_fixup = .;
 130         }
 131         . = ALIGN(8);
 132         __mmu_ftr_fixup : AT(ADDR(__mmu_ftr_fixup) - LOAD_OFFSET) {
 133                 __start___mmu_ftr_fixup = .;
 134                 *(__mmu_ftr_fixup)
 135                 __stop___mmu_ftr_fixup = .;
 136         }
 137         . = ALIGN(8);
 138         __lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
 139                 __start___lwsync_fixup = .;
 140                 *(__lwsync_fixup)
 141                 __stop___lwsync_fixup = .;
 142         }
 143 #ifdef CONFIG_PPC64
 144         . = ALIGN(8);
 145         __fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
 146                 __start___fw_ftr_fixup = .;
 147                 *(__fw_ftr_fixup)
 148                 __stop___fw_ftr_fixup = .;
 149         }
 150 #endif
 151         .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
 152                 INIT_RAM_FS
 153         }
 154
 155         PERCPU_SECTION(L1_CACHE_BYTES)
 156
 157         . = ALIGN(8);
 158         .machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
 159                 __machine_desc_start = . ;
 160                 *(.machine.desc)
 161                 __machine_desc_end = . ;
 162         }
 163 #ifdef CONFIG_RELOCATABLE
 164         . = ALIGN(8);
 165         .dynsym : AT(ADDR(.dynsym) - LOAD_OFFSET)
 166         {
 167 #ifdef CONFIG_RELOCATABLE_PPC32
 168                 __dynamic_symtab = .;
 169 #endif
 170                 *(.dynsym)
 171         }
 172         .dynstr : AT(ADDR(.dynstr) - LOAD_OFFSET) { *(.dynstr) }
 173         .dynamic : AT(ADDR(.dynamic) - LOAD_OFFSET)
 174         {
 175                 __dynamic_start = .;
 176                 *(.dynamic)
 177         }
 178         .hash : AT(ADDR(.hash) - LOAD_OFFSET) { *(.hash) }
 179         .interp : AT(ADDR(.interp) - LOAD_OFFSET) { *(.interp) }
 180         .rela.dyn : AT(ADDR(.rela.dyn) - LOAD_OFFSET)
 181         {
 182                 __rela_dyn_start = .;
 183                 *(.rela*)
 184         }
 185 #endif
 186         /* .exit.data is discarded at runtime, not link time,
 187          * to deal with references from .exit.text
 188          */
 189         .exit.data : AT(ADDR(.exit.data) - LOAD_OFFSET) {
 190                 EXIT_DATA
 191         }
 192
 193         /* freed after init ends here */
 194         . = ALIGN(PAGE_SIZE);
 195         __init_end = .;
 196
 197 /*
 198  * And now the various read/write data
 199  */
 200
 201         . = ALIGN(PAGE_SIZE);
 202         _sdata = .;
 203
 204 #ifdef CONFIG_PPC32
 205         .data : AT(ADDR(.data) - LOAD_OFFSET) {
 206                 DATA_DATA
 207                 *(.sdata)
 208                 *(.got.plt) *(.got)
 209         }
 210 #else
 211         .data : AT(ADDR(.data) - LOAD_OFFSET) {
 212                 DATA_DATA
 213                 *(.data.rel*)
 214                 *(.toc1)
 215                 *(.branch_lt)
 216         }
 217
 218         .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
 219                 *(.opd)
 220         }
 221
 222         . = ALIGN(256);
 223         .got : AT(ADDR(.got) - LOAD_OFFSET) {
 224                 __toc_start = .;
 225 #ifndef CONFIG_RELOCATABLE
 226                 __prom_init_toc_start = .;
 227                 arch/powerpc/kernel/prom_init.o*(.toc .got)
 228                 __prom_init_toc_end = .;
 229 #endif
 230                 *(.got)
 231                 *(.toc)
 232         }
 233 #endif
 234
 235         /* The initial task and kernel stack */
 236         INIT_TASK_DATA_SECTION(THREAD_SIZE)
 237
 238         .data..page_aligned : AT(ADDR(.data..page_aligned) - LOAD_OFFSET) {
 239                 PAGE_ALIGNED_DATA(PAGE_SIZE)
 240         }
 241
 242         .data..cacheline_aligned : AT(ADDR(.data..cacheline_aligned) - LOAD_OFFSET) {
 243                 CACHELINE_ALIGNED_DATA(L1_CACHE_BYTES)
 244         }
 245
 246         .data..read_mostly : AT(ADDR(.data..read_mostly) - LOAD_OFFSET) {
 247                 READ_MOSTLY_DATA(L1_CACHE_BYTES)
 248         }
 249
 250         . = ALIGN(PAGE_SIZE);
 251         .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
 252                 NOSAVE_DATA
 253         }
 254
 255         . = ALIGN(PAGE_SIZE);
 256         _edata  =  .;
 257         PROVIDE32 (edata = .);
 258
 259 /*
 260  * And finally the bss
 261  */
 262
 263         BSS_SECTION(0, 0, 0)
 264
 265         . = ALIGN(PAGE_SIZE);
 266         _end = . ;
 267         PROVIDE32 (end = .);
 268
 269         /* Sections to be discarded. */
 270         DISCARDS
 271 }