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 #ifdef CONFIG_PPC64
  13 OUTPUT_ARCH(powerpc:common64)
  14 jiffies = jiffies_64;
  15 #else
  16 OUTPUT_ARCH(powerpc:common)
  17 jiffies = jiffies_64 + 4;
  18 #endif
  19 SECTIONS
  20 {
  21         /* Sections to be discarded. */
  22         /DISCARD/ : {
  23         *(.exitcall.exit)
  24         EXIT_DATA
  25         }
  26
  27         . = KERNELBASE;
  28
  29 /*
  30  * Text, read only data and other permanent read-only sections
  31  */
  32
  33         /* Text and gots */
  34         .text : AT(ADDR(.text) - LOAD_OFFSET) {
  35                 ALIGN_FUNCTION();
  36                 *(.text.head)
  37                 _text = .;
  38                 *(.text .fixup .text.init.refok .exit.text.refok __ftr_alt_*)
  39                 SCHED_TEXT
  40                 LOCK_TEXT
  41                 KPROBES_TEXT
  42
  43 #ifdef CONFIG_PPC32
  44                 *(.got1)
  45                 __got2_start = .;
  46                 *(.got2)
  47                 __got2_end = .;
  48 #endif /* CONFIG_PPC32 */
  49
  50                 . = ALIGN(PAGE_SIZE);
  51                 _etext = .;
  52                 PROVIDE32 (etext = .);
  53         }
  54
  55         /* Read-only data */
  56         RODATA
  57
  58         /* Exception & bug tables */
  59         __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
  60                 __start___ex_table = .;
  61                 *(__ex_table)
  62                 __stop___ex_table = .;
  63         }
  64
  65         NOTES
  66
  67 /*
  68  * Init sections discarded at runtime
  69  */
  70         . = ALIGN(PAGE_SIZE);
  71         __init_begin = .;
  72
  73         .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
  74                 _sinittext = .;
  75                 INIT_TEXT
  76                 _einittext = .;
  77         }
  78
  79         /* .exit.text is discarded at runtime, not link time,
  80          * to deal with references from __bug_table
  81          */
  82         .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
  83                 EXIT_TEXT
  84         }
  85
  86         .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
  87                 INIT_DATA
  88                 __vtop_table_begin = .;
  89                 *(.vtop_fixup);
  90                 __vtop_table_end = .;
  91                 __ptov_table_begin = .;
  92                 *(.ptov_fixup);
  93                 __ptov_table_end = .;
  94 #ifdef CONFIG_PPC_ISERIES
  95                 __dt_strings_start = .;
  96                 *(.dt_strings);
  97                 __dt_strings_end = .;
  98 #endif
  99         }
 100
 101         . = ALIGN(16);
 102         .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
 103                 __setup_start = .;
 104                 *(.init.setup)
 105                 __setup_end = .;
 106         }
 107
 108         .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
 109                 __initcall_start = .;
 110                 INITCALLS
 111                 __initcall_end = .;
 112                 }
 113
 114         .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
 115                 __con_initcall_start = .;
 116                 *(.con_initcall.init)
 117                 __con_initcall_end = .;
 118         }
 119
 120         SECURITY_INIT
 121
 122         . = ALIGN(8);
 123         __ftr_fixup : AT(ADDR(__ftr_fixup) - LOAD_OFFSET) {
 124                 __start___ftr_fixup = .;
 125                 *(__ftr_fixup)
 126                 __stop___ftr_fixup = .;
 127         }
 128         . = ALIGN(8);
 129         __lwsync_fixup : AT(ADDR(__lwsync_fixup) - LOAD_OFFSET) {
 130                 __start___lwsync_fixup = .;
 131                 *(__lwsync_fixup)
 132                 __stop___lwsync_fixup = .;
 133         }
 134 #ifdef CONFIG_PPC64
 135         . = ALIGN(8);
 136         __fw_ftr_fixup : AT(ADDR(__fw_ftr_fixup) - LOAD_OFFSET) {
 137                 __start___fw_ftr_fixup = .;
 138                 *(__fw_ftr_fixup)
 139                 __stop___fw_ftr_fixup = .;
 140         }
 141 #endif
 142 #ifdef CONFIG_BLK_DEV_INITRD
 143         . = ALIGN(PAGE_SIZE);
 144         .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
 145                 __initramfs_start = .;
 146                 *(.init.ramfs)
 147                 __initramfs_end = .;
 148         }
 149 #endif
 150         . = ALIGN(PAGE_SIZE);
 151         .data.percpu  : AT(ADDR(.data.percpu) - LOAD_OFFSET) {
 152                 __per_cpu_start = .;
 153                 *(.data.percpu)
 154                 *(.data.percpu.shared_aligned)
 155                 __per_cpu_end = .;
 156         }
 157
 158         . = ALIGN(8);
 159         .machine.desc : AT(ADDR(.machine.desc) - LOAD_OFFSET) {
 160                 __machine_desc_start = . ;
 161                 *(.machine.desc)
 162                 __machine_desc_end = . ;
 163         }
 164
 165         /* freed after init ends here */
 166         . = ALIGN(PAGE_SIZE);
 167         __init_end = .;
 168
 169 /*
 170  * And now the various read/write data
 171  */
 172
 173         . = ALIGN(PAGE_SIZE);
 174         _sdata = .;
 175
 176 #ifdef CONFIG_PPC32
 177         .data : AT(ADDR(.data) - LOAD_OFFSET) {
 178                 DATA_DATA
 179                 *(.sdata)
 180                 *(.got.plt) *(.got)
 181         }
 182 #else
 183         .data : AT(ADDR(.data) - LOAD_OFFSET) {
 184                 DATA_DATA
 185                 *(.data.rel*)
 186                 *(.toc1)
 187                 *(.branch_lt)
 188         }
 189
 190         .opd : AT(ADDR(.opd) - LOAD_OFFSET) {
 191                 *(.opd)
 192         }
 193
 194         .got : AT(ADDR(.got) - LOAD_OFFSET) {
 195                 __toc_start = .;
 196                 *(.got)
 197                 *(.toc)
 198         }
 199 #endif
 200
 201         . = ALIGN(PAGE_SIZE);
 202         _edata  =  .;
 203         PROVIDE32 (edata = .);
 204
 205         /* The initial task and kernel stack */
 206 #ifdef CONFIG_PPC32
 207         . = ALIGN(8192);
 208 #else
 209         . = ALIGN(16384);
 210 #endif
 211         .data.init_task : AT(ADDR(.data.init_task) - LOAD_OFFSET) {
 212                 *(.data.init_task)
 213         }
 214
 215         . = ALIGN(PAGE_SIZE);
 216         .data.page_aligned : AT(ADDR(.data.page_aligned) - LOAD_OFFSET) {
 217                 *(.data.page_aligned)
 218         }
 219
 220         .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - LOAD_OFFSET) {
 221                 *(.data.cacheline_aligned)
 222         }
 223
 224         . = ALIGN(L1_CACHE_BYTES);
 225         .data.read_mostly : AT(ADDR(.data.read_mostly) - LOAD_OFFSET) {
 226                 *(.data.read_mostly)
 227         }
 228
 229         . = ALIGN(PAGE_SIZE);
 230         .data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
 231                 __nosave_begin = .;
 232                 *(.data.nosave)
 233                 . = ALIGN(PAGE_SIZE);
 234                 __nosave_end = .;
 235         }
 236
 237 /*
 238  * And finally the bss
 239  */
 240
 241         .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
 242                 __bss_start = .;
 243                 *(.sbss) *(.scommon)
 244                 *(.dynbss)
 245                 *(.bss)
 246                 *(COMMON)
 247                 __bss_stop = .;
 248         }
 249
 250         . = ALIGN(PAGE_SIZE);
 251         _end = . ;
 252         PROVIDE32 (end = .);
 253 }