Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 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 | * |
Marc Gauthier | 2d1c645 | 2013-01-05 04:57:17 +0400 | [diff] [blame] | 10 | * Copyright (C) 2001 - 2008 Tensilica Inc. |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 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> |
Tim Abbott | cd3db32 | 2009-09-24 10:36:19 -0400 | [diff] [blame] | 18 | #include <asm/page.h> |
| 19 | #include <asm/thread_info.h> |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 20 | |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 21 | #include <asm/vectors.h> |
Chris Zankel | 367b811 | 2008-11-06 06:40:46 -0800 | [diff] [blame] | 22 | #include <variant/core.h> |
Johannes Weiner | 6770fa0 | 2009-03-04 16:21:32 +0100 | [diff] [blame] | 23 | #include <platform/hardware.h> |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 24 | OUTPUT_ARCH(xtensa) |
| 25 | ENTRY(_start) |
| 26 | |
Chris Zankel | 173d6681 | 2006-12-10 02:18:48 -0800 | [diff] [blame] | 27 | #ifdef __XTENSA_EB__ |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 28 | jiffies = jiffies_64 + 4; |
| 29 | #else |
| 30 | jiffies = jiffies_64; |
| 31 | #endif |
| 32 | |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 33 | /* Note: In the following macros, it would be nice to specify only the |
| 34 | vector name and section kind and construct "sym" and "section" using |
| 35 | CPP concatenation, but that does not work reliably. Concatenating a |
| 36 | string with "." produces an invalid token. CPP will not print a |
| 37 | warning because it thinks this is an assembly file, but it leaves |
| 38 | them as multiple tokens and there may or may not be whitespace |
| 39 | between them. */ |
| 40 | |
| 41 | /* Macro for a relocation entry */ |
| 42 | |
| 43 | #define RELOCATE_ENTRY(sym, section) \ |
| 44 | LONG(sym ## _start); \ |
| 45 | LONG(sym ## _end); \ |
| 46 | LONG(LOADADDR(section)) |
| 47 | |
| 48 | /* Macro to define a section for a vector. |
| 49 | * |
| 50 | * Use of the MIN function catches the types of errors illustrated in |
| 51 | * the following example: |
| 52 | * |
| 53 | * Assume the section .DoubleExceptionVector.literal is completely |
| 54 | * full. Then a programmer adds code to .DoubleExceptionVector.text |
| 55 | * that produces another literal. The final literal position will |
| 56 | * overlay onto the first word of the adjacent code section |
| 57 | * .DoubleExceptionVector.text. (In practice, the literals will |
| 58 | * overwrite the code, and the first few instructions will be |
| 59 | * garbage.) |
| 60 | */ |
| 61 | |
| 62 | #define SECTION_VECTOR(sym, section, addr, max_prevsec_size, prevsec) \ |
| 63 | section addr : AT((MIN(LOADADDR(prevsec) + max_prevsec_size, \ |
| 64 | LOADADDR(prevsec) + SIZEOF(prevsec)) + 3) & ~ 3) \ |
| 65 | { \ |
| 66 | . = ALIGN(4); \ |
| 67 | sym ## _start = ABSOLUTE(.); \ |
| 68 | *(section) \ |
| 69 | sym ## _end = ABSOLUTE(.); \ |
| 70 | } |
| 71 | |
| 72 | /* |
| 73 | * Mapping of input sections to output sections when linking. |
| 74 | */ |
| 75 | |
| 76 | SECTIONS |
| 77 | { |
Chris Zankel | 173d6681 | 2006-12-10 02:18:48 -0800 | [diff] [blame] | 78 | . = KERNELOFFSET; |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 79 | /* .text section */ |
| 80 | |
| 81 | _text = .; |
| 82 | _stext = .; |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 83 | |
| 84 | .text : |
| 85 | { |
Tim Abbott | 0ebdcb4 | 2009-04-25 22:10:57 -0400 | [diff] [blame] | 86 | /* The HEAD_TEXT section must be the first section! */ |
| 87 | HEAD_TEXT |
Chris Zankel | 78f3cdf | 2009-04-21 00:34:15 -0700 | [diff] [blame] | 88 | TEXT_TEXT |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 89 | VMLINUX_SYMBOL(__sched_text_start) = .; |
Chris Zankel | 813e678 | 2005-07-12 13:58:25 -0700 | [diff] [blame] | 90 | *(.sched.literal .sched.text) |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 91 | VMLINUX_SYMBOL(__sched_text_end) = .; |
Chris Metcalf | 6727ad9 | 2016-10-07 17:02:55 -0700 | [diff] [blame^] | 92 | VMLINUX_SYMBOL(__cpuidle_text_start) = .; |
| 93 | *(.cpuidle.literal .cpuidle.text) |
| 94 | VMLINUX_SYMBOL(__cpuidle_text_end) = .; |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 95 | VMLINUX_SYMBOL(__lock_text_start) = .; |
Chris Zankel | 813e678 | 2005-07-12 13:58:25 -0700 | [diff] [blame] | 96 | *(.spinlock.literal .spinlock.text) |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 97 | VMLINUX_SYMBOL(__lock_text_end) = .; |
| 98 | |
| 99 | } |
| 100 | _etext = .; |
Chris Zankel | de4f6e5 | 2007-05-31 17:47:01 -0700 | [diff] [blame] | 101 | PROVIDE (etext = .); |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 102 | |
| 103 | . = ALIGN(16); |
| 104 | |
| 105 | RODATA |
| 106 | |
| 107 | /* Relocation table */ |
| 108 | |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 109 | .fixup : { *(.fixup) } |
| 110 | |
Tim Abbott | cd3db32 | 2009-09-24 10:36:19 -0400 | [diff] [blame] | 111 | EXCEPTION_TABLE(16) |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 112 | /* Data section */ |
| 113 | |
Geert Uytterhoeven | 5e7b6ed | 2012-06-20 12:52:58 -0700 | [diff] [blame] | 114 | _sdata = .; |
Tim Abbott | cd3db32 | 2009-09-24 10:36:19 -0400 | [diff] [blame] | 115 | RW_DATA_SECTION(XCHAL_ICACHE_LINESIZE, PAGE_SIZE, THREAD_SIZE) |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 116 | _edata = .; |
| 117 | |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 118 | /* Initialization code and data: */ |
| 119 | |
Tim Abbott | cd3db32 | 2009-09-24 10:36:19 -0400 | [diff] [blame] | 120 | . = ALIGN(PAGE_SIZE); |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 121 | __init_begin = .; |
Tim Abbott | cd3db32 | 2009-09-24 10:36:19 -0400 | [diff] [blame] | 122 | INIT_TEXT_SECTION(PAGE_SIZE) |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 123 | |
| 124 | .init.data : |
| 125 | { |
Sam Ravnborg | 01ba2bd | 2008-01-20 14:15:03 +0100 | [diff] [blame] | 126 | INIT_DATA |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 127 | . = ALIGN(0x4); |
| 128 | __tagtable_begin = .; |
| 129 | *(.taglist) |
| 130 | __tagtable_end = .; |
Chris Zankel | de4f6e5 | 2007-05-31 17:47:01 -0700 | [diff] [blame] | 131 | |
| 132 | . = ALIGN(16); |
| 133 | __boot_reloc_table_start = ABSOLUTE(.); |
| 134 | |
| 135 | RELOCATE_ENTRY(_WindowVectors_text, |
| 136 | .WindowVectors.text); |
Marc Gauthier | 2d1c645 | 2013-01-05 04:57:17 +0400 | [diff] [blame] | 137 | #if XCHAL_EXCM_LEVEL >= 2 |
| 138 | RELOCATE_ENTRY(_Level2InterruptVector_text, |
| 139 | .Level2InterruptVector.text); |
| 140 | #endif |
| 141 | #if XCHAL_EXCM_LEVEL >= 3 |
| 142 | RELOCATE_ENTRY(_Level3InterruptVector_text, |
| 143 | .Level3InterruptVector.text); |
| 144 | #endif |
| 145 | #if XCHAL_EXCM_LEVEL >= 4 |
| 146 | RELOCATE_ENTRY(_Level4InterruptVector_text, |
| 147 | .Level4InterruptVector.text); |
| 148 | #endif |
| 149 | #if XCHAL_EXCM_LEVEL >= 5 |
| 150 | RELOCATE_ENTRY(_Level5InterruptVector_text, |
| 151 | .Level5InterruptVector.text); |
| 152 | #endif |
| 153 | #if XCHAL_EXCM_LEVEL >= 6 |
| 154 | RELOCATE_ENTRY(_Level6InterruptVector_text, |
| 155 | .Level6InterruptVector.text); |
| 156 | #endif |
Chris Zankel | de4f6e5 | 2007-05-31 17:47:01 -0700 | [diff] [blame] | 157 | RELOCATE_ENTRY(_KernelExceptionVector_text, |
| 158 | .KernelExceptionVector.text); |
| 159 | RELOCATE_ENTRY(_UserExceptionVector_text, |
| 160 | .UserExceptionVector.text); |
| 161 | RELOCATE_ENTRY(_DoubleExceptionVector_literal, |
| 162 | .DoubleExceptionVector.literal); |
| 163 | RELOCATE_ENTRY(_DoubleExceptionVector_text, |
| 164 | .DoubleExceptionVector.text); |
Marc Gauthier | 6d15d10 | 2007-12-30 22:00:54 -0800 | [diff] [blame] | 165 | RELOCATE_ENTRY(_DebugInterruptVector_text, |
| 166 | .DebugInterruptVector.text); |
Max Filippov | f615136 | 2013-10-17 02:42:26 +0400 | [diff] [blame] | 167 | #if defined(CONFIG_SMP) |
Max Filippov | f615136 | 2013-10-17 02:42:26 +0400 | [diff] [blame] | 168 | RELOCATE_ENTRY(_SecondaryResetVector_text, |
| 169 | .SecondaryResetVector.text); |
| 170 | #endif |
| 171 | |
Chris Zankel | de4f6e5 | 2007-05-31 17:47:01 -0700 | [diff] [blame] | 172 | |
| 173 | __boot_reloc_table_end = ABSOLUTE(.) ; |
Tim Abbott | cd3db32 | 2009-09-24 10:36:19 -0400 | [diff] [blame] | 174 | |
| 175 | INIT_SETUP(XCHAL_ICACHE_LINESIZE) |
| 176 | INIT_CALLS |
| 177 | CON_INITCALL |
| 178 | SECURITY_INITCALL |
| 179 | INIT_RAM_FS |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 180 | } |
| 181 | |
Tejun Heo | 0415b00d1 | 2011-03-24 18:50:09 +0100 | [diff] [blame] | 182 | PERCPU_SECTION(XCHAL_ICACHE_LINESIZE) |
Chris Zankel | de4f6e5 | 2007-05-31 17:47:01 -0700 | [diff] [blame] | 183 | |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 184 | /* We need this dummy segment here */ |
| 185 | |
| 186 | . = ALIGN(4); |
| 187 | .dummy : { LONG(0) } |
| 188 | |
| 189 | /* The vectors are relocated to the real position at startup time */ |
| 190 | |
| 191 | SECTION_VECTOR (_WindowVectors_text, |
| 192 | .WindowVectors.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 193 | WINDOW_VECTORS_VADDR, 4, |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 194 | .dummy) |
| 195 | SECTION_VECTOR (_DebugInterruptVector_literal, |
| 196 | .DebugInterruptVector.literal, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 197 | DEBUG_VECTOR_VADDR - 4, |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 198 | SIZEOF(.WindowVectors.text), |
| 199 | .WindowVectors.text) |
| 200 | SECTION_VECTOR (_DebugInterruptVector_text, |
| 201 | .DebugInterruptVector.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 202 | DEBUG_VECTOR_VADDR, |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 203 | 4, |
| 204 | .DebugInterruptVector.literal) |
Marc Gauthier | 2d1c645 | 2013-01-05 04:57:17 +0400 | [diff] [blame] | 205 | #undef LAST |
| 206 | #define LAST .DebugInterruptVector.text |
| 207 | #if XCHAL_EXCM_LEVEL >= 2 |
| 208 | SECTION_VECTOR (_Level2InterruptVector_text, |
| 209 | .Level2InterruptVector.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 210 | INTLEVEL2_VECTOR_VADDR, |
Marc Gauthier | 2d1c645 | 2013-01-05 04:57:17 +0400 | [diff] [blame] | 211 | SIZEOF(LAST), LAST) |
| 212 | # undef LAST |
| 213 | # define LAST .Level2InterruptVector.text |
| 214 | #endif |
| 215 | #if XCHAL_EXCM_LEVEL >= 3 |
| 216 | SECTION_VECTOR (_Level3InterruptVector_text, |
| 217 | .Level3InterruptVector.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 218 | INTLEVEL3_VECTOR_VADDR, |
Marc Gauthier | 2d1c645 | 2013-01-05 04:57:17 +0400 | [diff] [blame] | 219 | SIZEOF(LAST), LAST) |
| 220 | # undef LAST |
| 221 | # define LAST .Level3InterruptVector.text |
| 222 | #endif |
| 223 | #if XCHAL_EXCM_LEVEL >= 4 |
| 224 | SECTION_VECTOR (_Level4InterruptVector_text, |
| 225 | .Level4InterruptVector.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 226 | INTLEVEL4_VECTOR_VADDR, |
Marc Gauthier | 2d1c645 | 2013-01-05 04:57:17 +0400 | [diff] [blame] | 227 | SIZEOF(LAST), LAST) |
| 228 | # undef LAST |
| 229 | # define LAST .Level4InterruptVector.text |
| 230 | #endif |
| 231 | #if XCHAL_EXCM_LEVEL >= 5 |
| 232 | SECTION_VECTOR (_Level5InterruptVector_text, |
| 233 | .Level5InterruptVector.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 234 | INTLEVEL5_VECTOR_VADDR, |
Marc Gauthier | 2d1c645 | 2013-01-05 04:57:17 +0400 | [diff] [blame] | 235 | SIZEOF(LAST), LAST) |
| 236 | # undef LAST |
| 237 | # define LAST .Level5InterruptVector.text |
| 238 | #endif |
| 239 | #if XCHAL_EXCM_LEVEL >= 6 |
| 240 | SECTION_VECTOR (_Level6InterruptVector_text, |
| 241 | .Level6InterruptVector.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 242 | INTLEVEL6_VECTOR_VADDR, |
Marc Gauthier | 2d1c645 | 2013-01-05 04:57:17 +0400 | [diff] [blame] | 243 | SIZEOF(LAST), LAST) |
| 244 | # undef LAST |
| 245 | # define LAST .Level6InterruptVector.text |
| 246 | #endif |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 247 | SECTION_VECTOR (_KernelExceptionVector_literal, |
| 248 | .KernelExceptionVector.literal, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 249 | KERNEL_VECTOR_VADDR - 4, |
Marc Gauthier | 2d1c645 | 2013-01-05 04:57:17 +0400 | [diff] [blame] | 250 | SIZEOF(LAST), LAST) |
| 251 | #undef LAST |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 252 | SECTION_VECTOR (_KernelExceptionVector_text, |
| 253 | .KernelExceptionVector.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 254 | KERNEL_VECTOR_VADDR, |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 255 | 4, |
| 256 | .KernelExceptionVector.literal) |
| 257 | SECTION_VECTOR (_UserExceptionVector_literal, |
| 258 | .UserExceptionVector.literal, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 259 | USER_VECTOR_VADDR - 4, |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 260 | SIZEOF(.KernelExceptionVector.text), |
| 261 | .KernelExceptionVector.text) |
| 262 | SECTION_VECTOR (_UserExceptionVector_text, |
| 263 | .UserExceptionVector.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 264 | USER_VECTOR_VADDR, |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 265 | 4, |
| 266 | .UserExceptionVector.literal) |
| 267 | SECTION_VECTOR (_DoubleExceptionVector_literal, |
| 268 | .DoubleExceptionVector.literal, |
Max Filippov | 3cfc096 | 2014-08-07 01:03:01 +0400 | [diff] [blame] | 269 | DOUBLEEXC_VECTOR_VADDR - 48, |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 270 | SIZEOF(.UserExceptionVector.text), |
| 271 | .UserExceptionVector.text) |
| 272 | SECTION_VECTOR (_DoubleExceptionVector_text, |
| 273 | .DoubleExceptionVector.text, |
Max Filippov | e85e335 | 2012-12-03 15:01:43 +0400 | [diff] [blame] | 274 | DOUBLEEXC_VECTOR_VADDR, |
Max Filippov | 3cfc096 | 2014-08-07 01:03:01 +0400 | [diff] [blame] | 275 | 48, |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 276 | .DoubleExceptionVector.literal) |
| 277 | |
| 278 | . = (LOADADDR( .DoubleExceptionVector.text ) + SIZEOF( .DoubleExceptionVector.text ) + 3) & ~ 3; |
Max Filippov | f615136 | 2013-10-17 02:42:26 +0400 | [diff] [blame] | 279 | |
| 280 | #if defined(CONFIG_SMP) |
| 281 | |
Max Filippov | f615136 | 2013-10-17 02:42:26 +0400 | [diff] [blame] | 282 | SECTION_VECTOR (_SecondaryResetVector_text, |
| 283 | .SecondaryResetVector.text, |
| 284 | RESET_VECTOR1_VADDR, |
Max Filippov | ab45fb1 | 2015-10-16 17:01:04 +0300 | [diff] [blame] | 285 | SIZEOF(.DoubleExceptionVector.text), |
| 286 | .DoubleExceptionVector.text) |
Max Filippov | f615136 | 2013-10-17 02:42:26 +0400 | [diff] [blame] | 287 | |
| 288 | . = LOADADDR(.SecondaryResetVector.text)+SIZEOF(.SecondaryResetVector.text); |
| 289 | |
| 290 | #endif |
| 291 | |
Tim Abbott | cd3db32 | 2009-09-24 10:36:19 -0400 | [diff] [blame] | 292 | . = ALIGN(PAGE_SIZE); |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 293 | |
| 294 | __init_end = .; |
| 295 | |
Tim Abbott | cd3db32 | 2009-09-24 10:36:19 -0400 | [diff] [blame] | 296 | BSS_SECTION(0, 8192, 0) |
Chris Zankel | de4f6e5 | 2007-05-31 17:47:01 -0700 | [diff] [blame] | 297 | |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 298 | _end = .; |
| 299 | |
Chris Zankel | de4f6e5 | 2007-05-31 17:47:01 -0700 | [diff] [blame] | 300 | .xt.lit : { *(.xt.lit) } |
| 301 | .xt.prop : { *(.xt.prop) } |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 302 | |
| 303 | .debug 0 : { *(.debug) } |
| 304 | .line 0 : { *(.line) } |
| 305 | .debug_srcinfo 0 : { *(.debug_srcinfo) } |
| 306 | .debug_sfnames 0 : { *(.debug_sfnames) } |
| 307 | .debug_aranges 0 : { *(.debug_aranges) } |
| 308 | .debug_pubnames 0 : { *(.debug_pubnames) } |
| 309 | .debug_info 0 : { *(.debug_info) } |
| 310 | .debug_abbrev 0 : { *(.debug_abbrev) } |
| 311 | .debug_line 0 : { *(.debug_line) } |
| 312 | .debug_frame 0 : { *(.debug_frame) } |
| 313 | .debug_str 0 : { *(.debug_str) } |
| 314 | .debug_loc 0 : { *(.debug_loc) } |
| 315 | .debug_macinfo 0 : { *(.debug_macinfo) } |
| 316 | .debug_weaknames 0 : { *(.debug_weaknames) } |
| 317 | .debug_funcnames 0 : { *(.debug_funcnames) } |
| 318 | .debug_typenames 0 : { *(.debug_typenames) } |
| 319 | .debug_varnames 0 : { *(.debug_varnames) } |
| 320 | |
| 321 | .xt.insn 0 : |
| 322 | { |
| 323 | *(.xt.insn) |
| 324 | *(.gnu.linkonce.x*) |
| 325 | } |
| 326 | |
| 327 | .xt.lit 0 : |
| 328 | { |
| 329 | *(.xt.lit) |
| 330 | *(.gnu.linkonce.p*) |
| 331 | } |
Tejun Heo | 023bf6f | 2009-07-09 11:27:40 +0900 | [diff] [blame] | 332 | |
| 333 | /* Sections to be discarded */ |
| 334 | DISCARDS |
| 335 | /DISCARD/ : { *(.exit.literal) } |
Chris Zankel | 5a0015d | 2005-06-23 22:01:16 -0700 | [diff] [blame] | 336 | } |