arch/blackfin/kernel/vmlinux.lds.S

   1 /*
   2  * Copyright 2004-2009 Analog Devices Inc.
   3  *
   4  * Licensed under the GPL-2 or later
   5  */
   6
   7 #include <asm-generic/vmlinux.lds.h>
   8 #include <asm/mem_map.h>
   9 #include <asm/page.h>
  10 #include <asm/thread_info.h>
  11
  12 OUTPUT_FORMAT("elf32-bfin")
  13 ENTRY(__start)
  14 _jiffies = _jiffies_64;
  15
  16 SECTIONS
  17 {
  18 #ifdef CONFIG_RAMKERNEL
  19         . = CONFIG_BOOT_LOAD;
  20 #else
  21         . = CONFIG_ROM_BASE;
  22 #endif
  23
  24         /* Neither the text, ro_data or bss section need to be aligned
  25          * So pack them back to back
  26          */
  27         .text :
  28         {
  29                 __text = .;
  30                 _text = .;
  31                 __stext = .;
  32                 TEXT_TEXT
  33 #ifndef CONFIG_SCHEDULE_L1
  34                 SCHED_TEXT
  35 #endif
  36                 CPUIDLE_TEXT
  37                 LOCK_TEXT
  38                 IRQENTRY_TEXT
  39                 SOFTIRQENTRY_TEXT
  40                 KPROBES_TEXT
  41 #ifdef CONFIG_ROMKERNEL
  42                 __sinittext = .;
  43                 INIT_TEXT
  44                 __einittext = .;
  45                 EXIT_TEXT
  46 #endif
  47                 *(.text.*)
  48                 *(.fixup)
  49
  50 #if !L1_CODE_LENGTH
  51                 *(.l1.text)
  52 #endif
  53                 __etext = .;
  54         }
  55
  56         EXCEPTION_TABLE(4)
  57         NOTES
  58
  59         /* Just in case the first read only is a 32-bit access */
  60         RO_DATA(4)
  61         __rodata_end = .;
  62
  63 #ifdef CONFIG_ROMKERNEL
  64         . = CONFIG_BOOT_LOAD;
  65         .bss : AT(__rodata_end)
  66 #else
  67         .bss :
  68 #endif
  69         {
  70                 . = ALIGN(4);
  71                 ___bss_start = .;
  72                 *(.bss .bss.*)
  73                 *(COMMON)
  74 #if !L1_DATA_A_LENGTH
  75                 *(.l1.bss)
  76 #endif
  77 #if !L1_DATA_B_LENGTH
  78                 *(.l1.bss.B)
  79 #endif
  80                 . = ALIGN(4);
  81                 ___bss_stop = .;
  82         }
  83
  84 #if defined(CONFIG_ROMKERNEL)
  85         .data : AT(LOADADDR(.bss) + SIZEOF(.bss))
  86 #else
  87         .data :
  88 #endif
  89         {
  90                 __sdata = .;
  91                 /* This gets done first, so the glob doesn't suck it in */
  92                 CACHELINE_ALIGNED_DATA(32)
  93
  94 #if !L1_DATA_A_LENGTH
  95                 . = ALIGN(32);
  96                 *(.data_l1.cacheline_aligned)
  97                 *(.l1.data)
  98 #endif
  99 #if !L1_DATA_B_LENGTH
 100                 *(.l1.data.B)
 101 #endif
 102 #if !L2_LENGTH
 103                 . = ALIGN(32);
 104                 *(.data_l2.cacheline_aligned)
 105                 *(.l2.data)
 106 #endif
 107
 108                 DATA_DATA
 109                 CONSTRUCTORS
 110
 111                 INIT_TASK_DATA(THREAD_SIZE)
 112
 113                 __edata = .;
 114         }
 115         __data_lma = LOADADDR(.data);
 116         __data_len = SIZEOF(.data);
 117
 118         /* The init section should be last, so when we free it, it goes into
 119          * the general memory pool, and (hopefully) will decrease fragmentation
 120          * a tiny bit. The init section has a _requirement_ that it be
 121          * PAGE_SIZE aligned
 122          */
 123         . = ALIGN(PAGE_SIZE);
 124         ___init_begin = .;
 125
 126 #ifdef CONFIG_RAMKERNEL
 127         INIT_TEXT_SECTION(PAGE_SIZE)
 128
 129         /* We have to discard exit text and such at runtime, not link time, to
 130          * handle embedded cross-section references (alt instructions, bug
 131          * table, eh_frame, etc...).  We need all of our .text up front and
 132          * .data after it for PCREL call issues.
 133          */
 134         .exit.text :
 135         {
 136                 EXIT_TEXT
 137         }
 138
 139         . = ALIGN(16);
 140         INIT_DATA_SECTION(16)
 141         PERCPU_SECTION(32)
 142
 143         .exit.data :
 144         {
 145                 EXIT_DATA
 146         }
 147
 148         .text_l1 L1_CODE_START : AT(LOADADDR(.exit.data) + SIZEOF(.exit.data))
 149 #else
 150         .init.data : AT(__data_lma + __data_len + 32)
 151         {
 152                 __sinitdata = .;
 153                 INIT_DATA
 154                 INIT_SETUP(16)
 155                 INIT_CALLS
 156                 CON_INITCALL
 157                 SECURITY_INITCALL
 158                 INIT_RAM_FS
 159
 160                 . = ALIGN(PAGE_SIZE);
 161                 ___per_cpu_load = .;
 162                 PERCPU_INPUT(32)
 163
 164                 EXIT_DATA
 165                 __einitdata = .;
 166         }
 167         __init_data_lma = LOADADDR(.init.data);
 168         __init_data_len = SIZEOF(.init.data);
 169         __init_data_end = .;
 170
 171         .text_l1 L1_CODE_START : AT(__init_data_lma + __init_data_len)
 172 #endif
 173         {
 174                 . = ALIGN(4);
 175                 __stext_l1 = .;
 176                 *(.l1.text.head)
 177                 *(.l1.text)
 178 #ifdef CONFIG_SCHEDULE_L1
 179                 SCHED_TEXT
 180 #endif
 181                 . = ALIGN(4);
 182                 __etext_l1 = .;
 183         }
 184         __text_l1_lma = LOADADDR(.text_l1);
 185         __text_l1_len = SIZEOF(.text_l1);
 186         ASSERT (__text_l1_len <= L1_CODE_LENGTH, "L1 text overflow!")
 187
 188         .data_l1 L1_DATA_A_START : AT(__text_l1_lma + __text_l1_len)
 189         {
 190                 . = ALIGN(4);
 191                 __sdata_l1 = .;
 192                 *(.l1.data)
 193                 __edata_l1 = .;
 194
 195                 . = ALIGN(32);
 196                 *(.data_l1.cacheline_aligned)
 197
 198                 . = ALIGN(4);
 199                 __sbss_l1 = .;
 200                 *(.l1.bss)
 201                 . = ALIGN(4);
 202                 __ebss_l1 = .;
 203         }
 204         __data_l1_lma = LOADADDR(.data_l1);
 205         __data_l1_len = SIZEOF(.data_l1);
 206         ASSERT (__data_l1_len <= L1_DATA_A_LENGTH, "L1 data A overflow!")
 207
 208         .data_b_l1 L1_DATA_B_START : AT(__data_l1_lma + __data_l1_len)
 209         {
 210                 . = ALIGN(4);
 211                 __sdata_b_l1 = .;
 212                 *(.l1.data.B)
 213                 __edata_b_l1 = .;
 214
 215                 . = ALIGN(4);
 216                 __sbss_b_l1 = .;
 217                 *(.l1.bss.B)
 218                 . = ALIGN(4);
 219                 __ebss_b_l1 = .;
 220         }
 221         __data_b_l1_lma = LOADADDR(.data_b_l1);
 222         __data_b_l1_len = SIZEOF(.data_b_l1);
 223         ASSERT (__data_b_l1_len <= L1_DATA_B_LENGTH, "L1 data B overflow!")
 224
 225         .text_data_l2 L2_START : AT(__data_b_l1_lma + __data_b_l1_len)
 226         {
 227                 . = ALIGN(4);
 228                 __stext_l2 = .;
 229                 *(.l2.text)
 230                 . = ALIGN(4);
 231                 __etext_l2 = .;
 232
 233                 . = ALIGN(4);
 234                 __sdata_l2 = .;
 235                 *(.l2.data)
 236                 __edata_l2 = .;
 237
 238                 . = ALIGN(32);
 239                 *(.data_l2.cacheline_aligned)
 240
 241                 . = ALIGN(4);
 242                 __sbss_l2 = .;
 243                 *(.l2.bss)
 244                 . = ALIGN(4);
 245                 __ebss_l2 = .;
 246         }
 247         __l2_lma = LOADADDR(.text_data_l2);
 248         __l2_len = SIZEOF(.text_data_l2);
 249         ASSERT (__l2_len <= L2_LENGTH, "L2 overflow!")
 250
 251         /* Force trailing alignment of our init section so that when we
 252          * free our init memory, we don't leave behind a partial page.
 253          */
 254 #ifdef CONFIG_RAMKERNEL
 255         . = __l2_lma + __l2_len;
 256 #else
 257         . = __init_data_end;
 258 #endif
 259         . = ALIGN(PAGE_SIZE);
 260         ___init_end = .;
 261
 262         __end =.;
 263
 264         STABS_DEBUG
 265
 266         DWARF_DEBUG
 267
 268         DISCARDS
 269 }