arch/xtensa/kernel/vmlinux.lds.S

   1 /*
   2  * arch/xtensa/kernel/vmlinux.lds.S
   3  *
   4  * Xtensa linker script
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file "COPYING" in the main directory of this archive
   8  * for more details.
   9  *
  10  * Copyright (C) 2001 - 2005 Tensilica Inc.
  11  *
  12  * Chris Zankel <chris@zankel.net>
  13  * Marc Gauthier <marc@tensilica.com, marc@alumni.uwaterloo.ca>
  14  * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
  15  */
  16
  17 #include <asm-generic/vmlinux.lds.h>
  18
  19 #include <asm/variant/core.h>
  20 OUTPUT_ARCH(xtensa)
  21 ENTRY(_start)
  22
  23 #ifdef __XTENSA_EB__
  24 jiffies = jiffies_64 + 4;
  25 #else
  26 jiffies = jiffies_64;
  27 #endif
  28
  29 #define KERNELOFFSET 0xd0001000
  30
  31 /* Note: In the following macros, it would be nice to specify only the
  32    vector name and section kind and construct "sym" and "section" using
  33    CPP concatenation, but that does not work reliably.  Concatenating a
  34    string with "." produces an invalid token.  CPP will not print a
  35    warning because it thinks this is an assembly file, but it leaves
  36    them as multiple tokens and there may or may not be whitespace
  37    between them.  */
  38
  39 /* Macro for a relocation entry */
  40
  41 #define RELOCATE_ENTRY(sym, section)            \
  42         LONG(sym ## _start);                    \
  43         LONG(sym ## _end);                      \
  44         LONG(LOADADDR(section))
  45
  46 /* Macro to define a section for a vector.
  47  *
  48  * Use of the MIN function catches the types of errors illustrated in
  49  * the following example:
  50  *
  51  * Assume the section .DoubleExceptionVector.literal is completely
  52  * full.  Then a programmer adds code to .DoubleExceptionVector.text
  53  * that produces another literal.  The final literal position will
  54  * overlay onto the first word of the adjacent code section
  55  * .DoubleExceptionVector.text.  (In practice, the literals will
  56  * overwrite the code, and the first few instructions will be
  57  * garbage.)
  58  */
  59
  60 #define SECTION_VECTOR(sym, section, addr, max_prevsec_size, prevsec)       \
  61   section addr : AT((MIN(LOADADDR(prevsec) + max_prevsec_size,              \
  62                          LOADADDR(prevsec) + SIZEOF(prevsec)) + 3) & ~ 3)   \
  63   {                                                                         \
  64     . = ALIGN(4);                                                           \
  65     sym ## _start = ABSOLUTE(.);                                            \
  66     *(section)                                                              \
  67     sym ## _end = ABSOLUTE(.);                                              \
  68   }
  69
  70 /*
  71  *  Mapping of input sections to output sections when linking.
  72  */
  73
  74 SECTIONS
  75 {
  76   . = KERNELOFFSET;
  77   /* .text section */
  78
  79   _text = .;
  80   _stext = .;
  81   _ftext = .;
  82
  83   .text :
  84   {
  85     /* The .head.text section must be the first section! */
  86     *(.head.text)
  87     *(.literal .text)
  88     VMLINUX_SYMBOL(__sched_text_start) = .;
  89     *(.sched.literal .sched.text)
  90     VMLINUX_SYMBOL(__sched_text_end) = .;
  91     VMLINUX_SYMBOL(__lock_text_start) = .;
  92     *(.spinlock.literal .spinlock.text)
  93     VMLINUX_SYMBOL(__lock_text_end) = .;
  94
  95   }
  96   _etext = .;
  97   PROVIDE (etext = .);
  98
  99   . = ALIGN(16);
 100
 101   RODATA
 102
 103   /*  Relocation table */
 104
 105   .fixup   : { *(.fixup) }
 106
 107   . = ALIGN(16);
 108
 109   __ex_table : {
 110     __start___ex_table = .;
 111     *(__ex_table)
 112     __stop___ex_table = .;
 113   }
 114
 115   /* Data section */
 116
 117   . = ALIGN(XCHAL_ICACHE_LINESIZE);
 118   _fdata = .;
 119   .data :
 120   {
 121     DATA_DATA
 122     CONSTRUCTORS
 123     . = ALIGN(XCHAL_ICACHE_LINESIZE);
 124     *(.data.cacheline_aligned)
 125   }
 126
 127   _edata = .;
 128
 129   /* The initial task */
 130   . = ALIGN(8192);
 131   .data.init_task : { *(.data.init_task) }
 132
 133   /* Initialization code and data: */
 134
 135   . = ALIGN(1 << 12);
 136   __init_begin = .;
 137   .init.text : {
 138         _sinittext = .;
 139 <<<<<<< HEAD:arch/xtensa/kernel/vmlinux.lds.S
 140         *(.init.literal) INIT_TEXT
 141 =======
 142         *(.init.literal) *(.cpuinit.literal)
 143         *(.devinit.literal) *(.meminit.literal)
 144         INIT_TEXT
 145 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:arch/xtensa/kernel/vmlinux.lds.S
 146         _einittext = .;
 147   }
 148
 149   .init.data :
 150   {
 151     INIT_DATA
 152     . = ALIGN(0x4);
 153     __tagtable_begin = .;
 154     *(.taglist)
 155     __tagtable_end = .;
 156
 157     . = ALIGN(16);
 158     __boot_reloc_table_start = ABSOLUTE(.);
 159
 160     RELOCATE_ENTRY(_WindowVectors_text,
 161                    .WindowVectors.text);
 162     RELOCATE_ENTRY(_KernelExceptionVector_text,
 163                    .KernelExceptionVector.text);
 164     RELOCATE_ENTRY(_UserExceptionVector_text,
 165                    .UserExceptionVector.text);
 166     RELOCATE_ENTRY(_DoubleExceptionVector_literal,
 167                    .DoubleExceptionVector.literal);
 168     RELOCATE_ENTRY(_DoubleExceptionVector_text,
 169                    .DoubleExceptionVector.text);
 170 <<<<<<< HEAD:arch/xtensa/kernel/vmlinux.lds.S
 171 =======
 172     RELOCATE_ENTRY(_DebugInterruptVector_text,
 173                    .DebugInterruptVector.text);
 174 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:arch/xtensa/kernel/vmlinux.lds.S
 175
 176     __boot_reloc_table_end = ABSOLUTE(.) ;
 177   }
 178
 179   . = ALIGN(XCHAL_ICACHE_LINESIZE);
 180
 181   __setup_start = .;
 182   .init.setup : { *(.init.setup) }
 183   __setup_end = .;
 184
 185   __initcall_start = .;
 186   .initcall.init : {
 187         INITCALLS
 188   }
 189   __initcall_end = .;
 190
 191   __con_initcall_start = .;
 192   .con_initcall.init : { *(.con_initcall.init) }
 193   __con_initcall_end = .;
 194
 195   SECURITY_INIT
 196
 197
 198 #ifdef CONFIG_BLK_DEV_INITRD
 199   . = ALIGN(4096);
 200   __initramfs_start =.;
 201   .init.ramfs : { *(.init.ramfs) }
 202   __initramfs_end = .;
 203 #endif
 204
 205   PERCPU(4096)
 206
 207
 208   /* We need this dummy segment here */
 209
 210   . = ALIGN(4);
 211   .dummy : { LONG(0) }
 212
 213   /* The vectors are relocated to the real position at startup time */
 214
 215   SECTION_VECTOR (_WindowVectors_text,
 216                   .WindowVectors.text,
 217                   XCHAL_WINDOW_VECTORS_VADDR, 4,
 218                   .dummy)
 219   SECTION_VECTOR (_DebugInterruptVector_literal,
 220                   .DebugInterruptVector.literal,
 221                   XCHAL_DEBUG_VECTOR_VADDR - 4,
 222                   SIZEOF(.WindowVectors.text),
 223                   .WindowVectors.text)
 224   SECTION_VECTOR (_DebugInterruptVector_text,
 225                   .DebugInterruptVector.text,
 226                   XCHAL_DEBUG_VECTOR_VADDR,
 227                   4,
 228                   .DebugInterruptVector.literal)
 229   SECTION_VECTOR (_KernelExceptionVector_literal,
 230                   .KernelExceptionVector.literal,
 231                   XCHAL_KERNEL_VECTOR_VADDR - 4,
 232                   SIZEOF(.DebugInterruptVector.text),
 233                   .DebugInterruptVector.text)
 234   SECTION_VECTOR (_KernelExceptionVector_text,
 235                   .KernelExceptionVector.text,
 236                   XCHAL_KERNEL_VECTOR_VADDR,
 237                   4,
 238                   .KernelExceptionVector.literal)
 239   SECTION_VECTOR (_UserExceptionVector_literal,
 240                   .UserExceptionVector.literal,
 241                   XCHAL_USER_VECTOR_VADDR - 4,
 242                   SIZEOF(.KernelExceptionVector.text),
 243                   .KernelExceptionVector.text)
 244   SECTION_VECTOR (_UserExceptionVector_text,
 245                   .UserExceptionVector.text,
 246                   XCHAL_USER_VECTOR_VADDR,
 247                   4,
 248                   .UserExceptionVector.literal)
 249   SECTION_VECTOR (_DoubleExceptionVector_literal,
 250                   .DoubleExceptionVector.literal,
 251                   XCHAL_DOUBLEEXC_VECTOR_VADDR - 16,
 252                   SIZEOF(.UserExceptionVector.text),
 253                   .UserExceptionVector.text)
 254   SECTION_VECTOR (_DoubleExceptionVector_text,
 255                   .DoubleExceptionVector.text,
 256                   XCHAL_DOUBLEEXC_VECTOR_VADDR,
 257                   32,
 258                   .DoubleExceptionVector.literal)
 259
 260   . = (LOADADDR( .DoubleExceptionVector.text ) + SIZEOF( .DoubleExceptionVector.text ) + 3) & ~ 3;
 261   . = ALIGN(1 << 12);
 262
 263   __init_end = .;
 264
 265   . = ALIGN(8192);
 266
 267   /* BSS section */
 268   _bss_start = .;
 269   .bss : { *(.bss.page_aligned) *(.bss) }
 270   _bss_end = .;
 271
 272   _end = .;
 273
 274   /* only used by the boot loader  */
 275
 276   . = ALIGN(0x10);
 277   .bootstrap : { *(.bootstrap.literal .bootstrap.text .bootstrap.data) }
 278
 279   . = ALIGN(0x1000);
 280   __initrd_start = .;
 281   .initrd : { *(.initrd) }
 282   __initrd_end = .;
 283
 284   .ResetVector.text XCHAL_RESET_VECTOR_VADDR :
 285   {
 286     *(.ResetVector.text)
 287   }
 288
 289   /* Sections to be discarded */
 290   /DISCARD/ :
 291   {
 292         *(.exit.literal)
 293         EXIT_TEXT
 294         EXIT_DATA
 295         *(.exitcall.exit)
 296   }
 297
 298   .xt.lit : { *(.xt.lit) }
 299   .xt.prop : { *(.xt.prop) }
 300
 301   .debug  0 :  { *(.debug) }
 302   .line  0 :  { *(.line) }
 303   .debug_srcinfo  0 :  { *(.debug_srcinfo) }
 304   .debug_sfnames  0 :  { *(.debug_sfnames) }
 305   .debug_aranges  0 :  { *(.debug_aranges) }
 306   .debug_pubnames  0 :  { *(.debug_pubnames) }
 307   .debug_info  0 :  { *(.debug_info) }
 308   .debug_abbrev  0 :  { *(.debug_abbrev) }
 309   .debug_line  0 :  { *(.debug_line) }
 310   .debug_frame  0 :  { *(.debug_frame) }
 311   .debug_str  0 :  { *(.debug_str) }
 312   .debug_loc  0 :  { *(.debug_loc) }
 313   .debug_macinfo  0 :  { *(.debug_macinfo) }
 314   .debug_weaknames  0 :  { *(.debug_weaknames) }
 315   .debug_funcnames  0 :  { *(.debug_funcnames) }
 316   .debug_typenames  0 :  { *(.debug_typenames) }
 317   .debug_varnames  0 :  { *(.debug_varnames) }
 318
 319   .xt.insn 0 :
 320   {
 321     *(.xt.insn)
 322     *(.gnu.linkonce.x*)
 323   }
 324
 325   .xt.lit 0 :
 326   {
 327     *(.xt.lit)
 328     *(.gnu.linkonce.p*)
 329   }
 330 }