arch/sh/kernel/vmlinux.lds.S

   1 /*
   2  * ld script to make SuperH Linux kernel
   3  * Written by Niibe Yutaka and Paul Mundt
   4  */
   5 #ifdef CONFIG_SUPERH64
   6 #define LOAD_OFFSET     CONFIG_PAGE_OFFSET
   7 OUTPUT_ARCH(sh:sh5)
   8 #else
   9 OUTPUT_ARCH(sh)
  10 #ifdef CONFIG_CPU_LITTLE_ENDIAN
  11 OUTPUT_FORMAT("elf32-sh-linux", "elf32-sh-linux", "elf32-sh-linux")
  12 #else
  13 OUTPUT_FORMAT("elf32-shbig-linux", "elf32-shbig-linux", "elf32-shbig-linux")
  14 #endif
  15 #endif
  16
  17 #include <asm/thread_info.h>
  18 #include <asm/cache.h>
  19 #include <asm-generic/vmlinux.lds.h>
  20
  21 ENTRY(_start)
  22 SECTIONS
  23 {
  24 #ifdef CONFIG_PMB_FIXED
  25         . = CONFIG_PAGE_OFFSET + (CONFIG_MEMORY_START & 0x1fffffff) +
  26             CONFIG_ZERO_PAGE_OFFSET;
  27 #elif defined(CONFIG_32BIT)
  28         . = CONFIG_PAGE_OFFSET + CONFIG_ZERO_PAGE_OFFSET;
  29 #else
  30         . = CONFIG_PAGE_OFFSET + CONFIG_MEMORY_START + CONFIG_ZERO_PAGE_OFFSET;
  31 #endif
  32
  33         .empty_zero_page : AT(ADDR(.empty_zero_page) - LOAD_OFFSET) {
  34                 *(.empty_zero_page)
  35         } = 0
  36
  37         .text : AT(ADDR(.text) - LOAD_OFFSET) {
  38                 _text = .;              /* Text and read-only data */
  39                 HEAD_TEXT
  40                 TEXT_TEXT
  41
  42 #ifdef CONFIG_SUPERH64
  43                 *(.text64)
  44                 *(.text..SHmedia32)
  45 #endif
  46
  47                 SCHED_TEXT
  48                 LOCK_TEXT
  49                 KPROBES_TEXT
  50                 IRQENTRY_TEXT
  51                 *(.fixup)
  52                 *(.gnu.warning)
  53                 _etext = .;             /* End of text section */
  54         } = 0x0009
  55
  56         . = ALIGN(16);          /* Exception table */
  57         __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
  58                 __start___ex_table = .;
  59                 *(__ex_table)
  60                 __stop___ex_table = .;
  61         }
  62
  63         NOTES
  64         RO_DATA(PAGE_SIZE)
  65
  66         /*
  67          * Code which must be executed uncached and the associated data
  68          */
  69         . = ALIGN(PAGE_SIZE);
  70         .uncached : AT(ADDR(.uncached) - LOAD_OFFSET) {
  71                 __uncached_start = .;
  72                 *(.uncached.text)
  73                 *(.uncached.data)
  74                 __uncached_end = .;
  75         }
  76
  77         . = ALIGN(THREAD_SIZE);
  78         .data : AT(ADDR(.data) - LOAD_OFFSET) {         /* Data */
  79                 *(.data.init_task)
  80
  81                 . = ALIGN(L1_CACHE_BYTES);
  82                 *(.data.cacheline_aligned)
  83
  84                 . = ALIGN(L1_CACHE_BYTES);
  85                 *(.data.read_mostly)
  86
  87                 . = ALIGN(PAGE_SIZE);
  88                 *(.data.page_aligned)
  89
  90                 __nosave_begin = .;
  91                 *(.data.nosave)
  92                 . = ALIGN(PAGE_SIZE);
  93                 __nosave_end = .;
  94
  95                 DATA_DATA
  96                 CONSTRUCTORS
  97         }
  98
  99         _edata = .;                     /* End of data section */
 100
 101         . = ALIGN(PAGE_SIZE);           /* Init code and data */
 102         .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
 103                 __init_begin = .;
 104                 _sinittext = .;
 105                 INIT_TEXT
 106                 _einittext = .;
 107         }
 108
 109         .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) { INIT_DATA }
 110
 111         . = ALIGN(16);
 112         .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
 113                 __setup_start = .;
 114                 *(.init.setup)
 115                 __setup_end = .;
 116         }
 117
 118         .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
 119                 __initcall_start = .;
 120                 INITCALLS
 121                 __initcall_end = .;
 122         }
 123
 124         .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
 125                 __con_initcall_start = .;
 126                 *(.con_initcall.init)
 127                 __con_initcall_end = .;
 128         }
 129
 130         SECURITY_INIT
 131
 132 #ifdef CONFIG_BLK_DEV_INITRD
 133         . = ALIGN(PAGE_SIZE);
 134         .init.ramfs : AT(ADDR(.init_ramfs) - LOAD_OFFSET) {
 135                 __initramfs_start = .;
 136                 *(.init.ramfs)
 137                 __initramfs_end = .;
 138         }
 139 #endif
 140
 141         . = ALIGN(4);
 142         .machvec.init : AT(ADDR(.machvec.init) - LOAD_OFFSET) {
 143                 __machvec_start = .;
 144                 *(.machvec.init)
 145                 __machvec_end = .;
 146         }
 147
 148         PERCPU(PAGE_SIZE)
 149
 150         /*
 151          * .exit.text is discarded at runtime, not link time, to deal with
 152          * references from __bug_table
 153          */
 154         .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) { EXIT_TEXT }
 155         .exit.data : AT(ADDR(.exit.data) - LOAD_OFFSET) { EXIT_DATA }
 156
 157         . = ALIGN(PAGE_SIZE);
 158         .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
 159                 __init_end = .;
 160                 __bss_start = .;                /* BSS */
 161                 *(.bss.page_aligned)
 162                 *(.bss)
 163                 *(COMMON)
 164                 . = ALIGN(4);
 165                 _ebss = .;                      /* uClinux MTD sucks */
 166                 _end = . ;
 167         }
 168
 169         /*
 170          * When something in the kernel is NOT compiled as a module, the
 171          * module cleanup code and data are put into these segments. Both
 172          * can then be thrown away, as cleanup code is never called unless
 173          * it's a module.
 174          */
 175         /DISCARD/ : {
 176                 *(.exitcall.exit)
 177         }
 178
 179         STABS_DEBUG
 180         DWARF_DEBUG
 181 }