source: rtems/bsps/arm/shared/start/linkcmds.base @ 511dc4b

Last change on this file since 511dc4b was 511dc4b, checked in by Sebastian Huber <sebastian.huber@…>, on Jun 19, 2018 at 7:09:51 AM

Rework initialization and interrupt stack support

Statically initialize the interrupt stack area
(_Configuration_Interrupt_stack_area_begin,
_Configuration_Interrupt_stack_area_end, and
_Configuration_Interrupt_stack_size) via <rtems/confdefs.h>. Place the
interrupt stack area in a special section ".rtemsstack.interrupt". Let
BSPs define the optimal placement of this section in their linker
command files (e.g. in a fast on-chip memory).

This change makes makes the CPU_HAS_SOFTWARE_INTERRUPT_STACK and
CPU_HAS_HARDWARE_INTERRUPT_STACK CPU port defines superfluous, since the
low level initialization code has all information available via global
symbols.

This change makes the CPU_ALLOCATE_INTERRUPT_STACK CPU port define
superfluous, since the interrupt stacks are allocated by confdefs.h for
all architectures. There is no need for BSP-specific linker command
file magic (except the section placement), see previous ARM linker
command file as a bad example.

Remove _CPU_Install_interrupt_stack(). Initialize the hardware
interrupt stack in _CPU_Initialize() if necessary (e.g.
m68k_install_interrupt_stack()).

The optional _CPU_Interrupt_stack_setup() is still useful to customize
the registration of the interrupt stack area in the per-CPU information.

The initialization stack can reuse the interrupt stack, since

  • interrupts are disabled during the sequential system initialization, and
  • the boot_card() function does not return.

This stack resuse saves memory.

Changes per architecture:

arm:

  • Mostly replace the linker symbol based configuration of stacks with the standard <rtems/confdefs.h> configuration via CONFIGURE_INTERRUPT_STACK_SIZE. The size of the FIQ, ABT and UND mode stack is still defined via linker symbols. These modes are rarely used in applications and the default values provided by the BSP should be sufficient in most cases.
  • Remove the bsp_processor_count linker symbol hack used for the SMP support. This is possible since the interrupt stack area is now allocated by the linker and not allocated from the heap. This makes some configure.ac stuff obsolete. Remove the now superfluous BSP variants altcycv_devkit_smp and realview_pbx_a9_qemu_smp.

bfin:

  • Remove unused magic linker command file allocation of initialization stack. Maybe a previous linker command file copy and paste problem? In the start.S the initialization stack is set to a hard coded value.

lm32, m32c, mips, nios2, riscv, sh, v850:

  • Remove magic linker command file allocation of initialization stack. Reuse interrupt stack for initialization stack.

m68k:

  • Remove magic linker command file allocation of initialization stack. Reuse interrupt stack for initialization stack.

powerpc:

  • Remove magic linker command file allocation of initialization stack. Reuse interrupt stack for initialization stack.
  • Used dedicated memory region (REGION_RTEMSSTACK) for the interrupt stack on BSPs using the shared linkcmds.base (replacement for REGION_RWEXTRA).

sparc:

  • Remove the hard coded initialization stack. Use the interrupt stack for the initialization stack on the boot processor. This saves 16KiB of RAM.

Update #3459.

  • Property mode set to 100644
File size: 15.5 KB
Line 
1/**
2 * @file
3 *
4 * @ingroup bsp_linker
5 *
6 * @brief Linker command base file.
7 */
8
9/*
10 * Copyright (c) 2008, 2016 embedded brains GmbH.  All rights reserved.
11 *
12 *  embedded brains GmbH
13 *  Dornierstr. 4
14 *  82178 Puchheim
15 *  Germany
16 *  <rtems@embedded-brains.de>
17 *
18 * The license and distribution terms for this file may be
19 * found in the file LICENSE in this distribution or at
20 * http://www.rtems.org/license/LICENSE.
21 */
22
23OUTPUT_FORMAT ("elf32-littlearm", "elf32-bigarm", "elf32-littlearm")
24
25OUTPUT_ARCH (arm)
26
27ENTRY (_start)
28STARTUP (start.o)
29
30/*
31 * Global symbols that may be defined externally
32 */
33
34bsp_vector_table_size = DEFINED (bsp_vector_table_size) ? bsp_vector_table_size : 64;
35
36bsp_section_xbarrier_align = DEFINED (bsp_section_xbarrier_align) ? bsp_section_xbarrier_align : 1;
37bsp_section_robarrier_align = DEFINED (bsp_section_robarrier_align) ? bsp_section_robarrier_align : 1;
38bsp_section_rwbarrier_align = DEFINED (bsp_section_rwbarrier_align) ? bsp_section_rwbarrier_align : 1;
39
40bsp_stack_align = DEFINED (bsp_stack_align) ? bsp_stack_align : 8;
41
42bsp_stack_abt_size = DEFINED (bsp_stack_abt_size) ? bsp_stack_abt_size : 0;
43bsp_stack_abt_size = ALIGN (bsp_stack_abt_size, bsp_stack_align);
44
45bsp_stack_fiq_size = DEFINED (bsp_stack_fiq_size) ? bsp_stack_fiq_size : 0;
46bsp_stack_fiq_size = ALIGN (bsp_stack_fiq_size, bsp_stack_align);
47
48bsp_stack_und_size = DEFINED (bsp_stack_und_size) ? bsp_stack_und_size : 0;
49bsp_stack_und_size = ALIGN (bsp_stack_und_size, bsp_stack_align);
50
51bsp_stack_hyp_size = DEFINED (bsp_stack_hyp_size) ? bsp_stack_hyp_size : 0;
52bsp_stack_hyp_size = ALIGN (bsp_stack_hyp_size, bsp_stack_align);
53
54MEMORY {
55        UNEXPECTED_SECTIONS : ORIGIN = 0xffffffff, LENGTH = 0
56}
57
58SECTIONS {
59        .start : ALIGN_WITH_INPUT {
60                bsp_section_start_begin = .;
61                KEEP (*(.bsp_start_text))
62                KEEP (*(.bsp_start_data))
63                bsp_section_start_end = .;
64        } > REGION_START AT > REGION_START
65        bsp_section_start_size = bsp_section_start_end - bsp_section_start_begin;
66
67        .xbarrier : ALIGN_WITH_INPUT {
68                . = ALIGN (bsp_section_xbarrier_align);
69        } > REGION_VECTOR AT > REGION_VECTOR
70
71        .text : ALIGN_WITH_INPUT {
72                bsp_section_text_begin = .;
73                *(.text.unlikely .text.*_unlikely)
74                *(.text .stub .text.* .gnu.linkonce.t.*)
75                /* .gnu.warning sections are handled specially by elf32.em.  */
76                *(.gnu.warning)
77                *(.glue_7t) *(.glue_7) *(.vfp11_veneer) *(.v4_bx)
78        } > REGION_TEXT AT > REGION_TEXT_LOAD
79        .init : ALIGN_WITH_INPUT {
80                KEEP (*(.init))
81        } > REGION_TEXT AT > REGION_TEXT_LOAD
82        .fini : ALIGN_WITH_INPUT {
83                KEEP (*(.fini))
84                bsp_section_text_end = .;
85        } > REGION_TEXT AT > REGION_TEXT_LOAD
86        bsp_section_text_size = bsp_section_text_end - bsp_section_text_begin;
87        bsp_section_text_load_begin = LOADADDR (.text);
88        bsp_section_text_load_end = bsp_section_text_load_begin + bsp_section_text_size;
89
90        .robarrier : ALIGN_WITH_INPUT {
91                . = ALIGN (bsp_section_robarrier_align);
92        } > REGION_RODATA AT > REGION_RODATA
93
94        .rodata : ALIGN_WITH_INPUT {
95                bsp_section_rodata_begin = .;
96                *(.rodata .rodata.* .gnu.linkonce.r.*)
97        } > REGION_RODATA AT > REGION_RODATA_LOAD
98        .rodata1 : ALIGN_WITH_INPUT {
99                *(.rodata1)
100        } > REGION_RODATA AT > REGION_RODATA_LOAD
101        .ARM.extab : ALIGN_WITH_INPUT {
102                *(.ARM.extab* .gnu.linkonce.armextab.*)
103        } > REGION_RODATA AT > REGION_RODATA_LOAD
104        .ARM.exidx : ALIGN_WITH_INPUT {
105                __exidx_start = .;
106                *(.ARM.exidx* .gnu.linkonce.armexidx.*)
107                __exidx_end = .;
108        } > REGION_RODATA AT > REGION_RODATA_LOAD
109        .eh_frame : ALIGN_WITH_INPUT {
110                KEEP (*(.eh_frame))
111        } > REGION_RODATA AT > REGION_RODATA_LOAD
112        .gcc_except_table : ALIGN_WITH_INPUT {
113                *(.gcc_except_table .gcc_except_table.*)
114        } > REGION_RODATA AT > REGION_RODATA_LOAD
115        .tdata : ALIGN_WITH_INPUT {
116                _TLS_Data_begin = .;
117                *(.tdata .tdata.* .gnu.linkonce.td.*)
118                _TLS_Data_end = .;
119        } > REGION_RODATA AT > REGION_RODATA_LOAD
120        .tbss : ALIGN_WITH_INPUT {
121                _TLS_BSS_begin = .;
122                *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon)
123                _TLS_BSS_end = .;
124        } > REGION_RODATA AT > REGION_RODATA_LOAD
125        _TLS_Data_size = _TLS_Data_end - _TLS_Data_begin;
126        _TLS_Data_begin = _TLS_Data_size != 0 ? _TLS_Data_begin : _TLS_BSS_begin;
127        _TLS_Data_end = _TLS_Data_size != 0 ? _TLS_Data_end : _TLS_BSS_begin;
128        _TLS_BSS_size = _TLS_BSS_end - _TLS_BSS_begin;
129        _TLS_Size = _TLS_BSS_end - _TLS_Data_begin;
130        _TLS_Alignment = MAX (ALIGNOF (.tdata), ALIGNOF (.tbss));
131        .preinit_array : ALIGN_WITH_INPUT {
132                PROVIDE_HIDDEN (__preinit_array_start = .);
133                KEEP (*(.preinit_array))
134                PROVIDE_HIDDEN (__preinit_array_end = .);
135        } > REGION_RODATA AT > REGION_RODATA_LOAD
136        .init_array : ALIGN_WITH_INPUT {
137                PROVIDE_HIDDEN (__init_array_start = .);
138                KEEP (*(SORT(.init_array.*)))
139                KEEP (*(.init_array))
140                PROVIDE_HIDDEN (__init_array_end = .);
141        } > REGION_RODATA AT > REGION_RODATA_LOAD
142        .fini_array : ALIGN_WITH_INPUT {
143                PROVIDE_HIDDEN (__fini_array_start = .);
144                KEEP (*(.fini_array))
145                KEEP (*(SORT(.fini_array.*)))
146                PROVIDE_HIDDEN (__fini_array_end = .);
147        } > REGION_RODATA AT > REGION_RODATA_LOAD
148        .ctors : ALIGN_WITH_INPUT {
149                /* gcc uses crtbegin.o to find the start of
150                   the constructors, so we make sure it is
151                   first.  Because this is a wildcard, it
152                   doesn't matter if the user does not
153                   actually link against crtbegin.o; the
154                   linker won't look for a file to match a
155                   wildcard.  The wildcard also means that it
156                   doesn't matter which directory crtbegin.o
157                   is in.  */
158                KEEP (*crtbegin.o(.ctors))
159                KEEP (*crtbegin?.o(.ctors))
160                /* We don't want to include the .ctor section from
161                   the crtend.o file until after the sorted ctors.
162                   The .ctor section from the crtend file contains the
163                   end of ctors marker and it must be last */
164                KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
165                KEEP (*(SORT(.ctors.*)))
166                KEEP (*(.ctors))
167        } > REGION_RODATA AT > REGION_RODATA_LOAD
168        .dtors : ALIGN_WITH_INPUT {
169                KEEP (*crtbegin.o(.dtors))
170                KEEP (*crtbegin?.o(.dtors))
171                KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
172                KEEP (*(SORT(.dtors.*)))
173                KEEP (*(.dtors))
174        } > REGION_RODATA AT > REGION_RODATA_LOAD
175        .data.rel.ro : ALIGN_WITH_INPUT {
176                *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*)
177                *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*)
178        } > REGION_RODATA AT > REGION_RODATA_LOAD
179        .jcr : ALIGN_WITH_INPUT {
180                KEEP (*(.jcr))
181        } > REGION_RODATA AT > REGION_RODATA_LOAD
182        .interp : ALIGN_WITH_INPUT {
183                *(.interp)
184        } > REGION_RODATA AT > REGION_RODATA_LOAD
185        .note.gnu.build-id : ALIGN_WITH_INPUT {
186                *(.note.gnu.build-id)
187        } > REGION_RODATA AT > REGION_RODATA_LOAD
188        .hash : ALIGN_WITH_INPUT {
189                *(.hash)
190        } > REGION_RODATA AT > REGION_RODATA_LOAD
191        .gnu.hash : ALIGN_WITH_INPUT {
192                *(.gnu.hash)
193        } > REGION_RODATA AT > REGION_RODATA_LOAD
194        .dynsym : ALIGN_WITH_INPUT {
195                *(.dynsym)
196        } > REGION_RODATA AT > REGION_RODATA_LOAD
197        .dynstr : ALIGN_WITH_INPUT {
198                *(.dynstr)
199        } > REGION_RODATA AT > REGION_RODATA_LOAD
200        .gnu.version : ALIGN_WITH_INPUT {
201                *(.gnu.version)
202        } > REGION_RODATA AT > REGION_RODATA_LOAD
203        .gnu.version_d : ALIGN_WITH_INPUT {
204                *(.gnu.version_d)
205        } > REGION_RODATA AT > REGION_RODATA_LOAD
206        .gnu.version_r : ALIGN_WITH_INPUT {
207                *(.gnu.version_r)
208        } > REGION_RODATA AT > REGION_RODATA_LOAD
209        .rel.dyn : ALIGN_WITH_INPUT {
210                *(.rel.init)
211                *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*)
212                *(.rel.fini)
213                *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*)
214                *(.rel.data.rel.ro* .rel.gnu.linkonce.d.rel.ro.*)
215                *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*)
216                *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*)
217                *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*)
218                *(.rel.ctors)
219                *(.rel.dtors)
220                *(.rel.got)
221                *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*)
222                PROVIDE_HIDDEN (__rel_iplt_start = .);
223                *(.rel.iplt)
224                PROVIDE_HIDDEN (__rel_iplt_end = .);
225                PROVIDE_HIDDEN (__rela_iplt_start = .);
226                PROVIDE_HIDDEN (__rela_iplt_end = .);
227        } > REGION_RODATA AT > REGION_RODATA_LOAD
228        .rela.dyn : ALIGN_WITH_INPUT {
229                *(.rela.init)
230                *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
231                *(.rela.fini)
232                *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
233                *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
234                *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
235                *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
236                *(.rela.ctors)
237                *(.rela.dtors)
238                *(.rela.got)
239                *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
240                *(.rela.rtemsroset*)
241                *(.rela.rtemsrwset*)
242                PROVIDE_HIDDEN (__rel_iplt_start = .);
243                PROVIDE_HIDDEN (__rel_iplt_end = .);
244                PROVIDE_HIDDEN (__rela_iplt_start = .);
245                *(.rela.iplt)
246                PROVIDE_HIDDEN (__rela_iplt_end = .);
247        } > REGION_RODATA AT > REGION_RODATA_LOAD
248        .rel.plt : ALIGN_WITH_INPUT {
249                *(.rel.plt)
250        } > REGION_RODATA AT > REGION_RODATA_LOAD
251        .rela.plt : ALIGN_WITH_INPUT {
252                *(.rela.plt)
253        } > REGION_RODATA AT > REGION_RODATA_LOAD
254        .plt : ALIGN_WITH_INPUT {
255                *(.plt)
256        } > REGION_RODATA AT > REGION_RODATA_LOAD
257        .iplt : ALIGN_WITH_INPUT {
258                *(.iplt)
259        } > REGION_RODATA AT > REGION_RODATA_LOAD
260        .dynamic : ALIGN_WITH_INPUT {
261                *(.dynamic)
262        } > REGION_RODATA AT > REGION_RODATA_LOAD
263        .got : ALIGN_WITH_INPUT {
264                *(.got.plt) *(.igot.plt) *(.got) *(.igot)
265        } > REGION_RODATA AT > REGION_RODATA_LOAD
266        .rtemsroset : ALIGN_WITH_INPUT {
267                /* Special FreeBSD linker set sections */
268                __start_set_sysctl_set = .;
269                *(set_sysctl_*);
270                __stop_set_sysctl_set = .;
271                *(set_domain_*);
272                *(set_pseudo_*);
273
274                KEEP (*(SORT(.rtemsroset.*)))
275                bsp_section_rodata_end = .;
276        } > REGION_RODATA AT > REGION_RODATA_LOAD
277        bsp_section_rodata_size = bsp_section_rodata_end - bsp_section_rodata_begin;
278        bsp_section_rodata_load_begin = LOADADDR (.rodata);
279        bsp_section_rodata_load_end = bsp_section_rodata_load_begin + bsp_section_rodata_size;
280
281        .rwbarrier : ALIGN_WITH_INPUT {
282                . = ALIGN (bsp_section_rwbarrier_align);
283        } > REGION_DATA AT > REGION_DATA
284
285        .vector : ALIGN_WITH_INPUT {
286                bsp_section_vector_begin = .;
287                . = . + DEFINED (bsp_vector_table_in_start_section) ? 0 : bsp_vector_table_size;
288        } > REGION_VECTOR AT > REGION_VECTOR
289        .rtemsstack (NOLOAD) : {
290                *(SORT(.rtemsstack.*))
291                bsp_section_vector_end = .;
292        } > REGION_VECTOR AT > REGION_VECTOR
293        bsp_section_vector_size = bsp_section_vector_end - bsp_section_vector_begin;
294        bsp_vector_table_begin = DEFINED (bsp_vector_table_in_start_section) ? bsp_section_start_begin : bsp_section_vector_begin;
295        bsp_vector_table_end = bsp_vector_table_begin + bsp_vector_table_size;
296
297        .fast_text : ALIGN_WITH_INPUT {
298                bsp_section_fast_text_begin = .;
299                *(.bsp_fast_text)
300                bsp_section_fast_text_end = .;
301        } > REGION_FAST_TEXT AT > REGION_FAST_TEXT_LOAD
302        bsp_section_fast_text_size = bsp_section_fast_text_end - bsp_section_fast_text_begin;
303        bsp_section_fast_text_load_begin = LOADADDR (.fast_text);
304        bsp_section_fast_text_load_end = bsp_section_fast_text_load_begin + bsp_section_fast_text_size;
305
306        .fast_data : ALIGN_WITH_INPUT {
307                bsp_section_fast_data_begin = .;
308                *(.bsp_fast_data)
309                bsp_section_fast_data_end = .;
310        } > REGION_FAST_DATA AT > REGION_FAST_DATA_LOAD
311        bsp_section_fast_data_size = bsp_section_fast_data_end - bsp_section_fast_data_begin;
312        bsp_section_fast_data_load_begin = LOADADDR (.fast_data);
313        bsp_section_fast_data_load_end = bsp_section_fast_data_load_begin + bsp_section_fast_data_size;
314
315        .data : ALIGN_WITH_INPUT {
316                bsp_section_data_begin = .;
317                *(.data .data.* .gnu.linkonce.d.*)
318                SORT(CONSTRUCTORS)
319        } > REGION_DATA AT > REGION_DATA_LOAD
320        .data1 : ALIGN_WITH_INPUT {
321                *(.data1)
322        } > REGION_DATA AT > REGION_DATA_LOAD
323        .rtemsrwset : ALIGN_WITH_INPUT {
324                KEEP (*(SORT(.rtemsrwset.*)))
325                bsp_section_data_end = .;
326        } > REGION_DATA AT > REGION_DATA_LOAD
327        bsp_section_data_size = bsp_section_data_end - bsp_section_data_begin;
328        bsp_section_data_load_begin = LOADADDR (.data);
329        bsp_section_data_load_end = bsp_section_data_load_begin + bsp_section_data_size;
330
331        .bss : ALIGN_WITH_INPUT {
332                bsp_section_bss_begin = .;
333                *(.dynbss)
334                *(.bss .bss.* .gnu.linkonce.b.*)
335                *(COMMON)
336                bsp_section_bss_end = .;
337        } > REGION_BSS AT > REGION_BSS
338        bsp_section_bss_size = bsp_section_bss_end - bsp_section_bss_begin;
339
340        .work : ALIGN_WITH_INPUT {
341                /*
342                 * The work section will occupy the remaining REGION_WORK region and
343                 * contains the RTEMS work space and heap.
344                 */
345                bsp_section_work_begin = .;
346                . += ORIGIN (REGION_WORK) + LENGTH (REGION_WORK) - ABSOLUTE (.);
347                bsp_section_work_end = .;
348        } > REGION_WORK AT > REGION_WORK
349        bsp_section_work_size = bsp_section_work_end - bsp_section_work_begin;
350
351        .stack : ALIGN_WITH_INPUT {
352                /*
353                 * The stack section will occupy the remaining REGION_STACK region and may
354                 * contain the task stacks.  Depending on the region distribution this
355                 * section may be of zero size.
356                 */
357                bsp_section_stack_begin = .;
358                . += ORIGIN (REGION_STACK) + LENGTH (REGION_STACK) - ABSOLUTE (.);
359                bsp_section_stack_end = .;
360        } > REGION_STACK AT > REGION_STACK
361        bsp_section_stack_size = bsp_section_stack_end - bsp_section_stack_begin;
362
363        .nocache : ALIGN_WITH_INPUT {
364                bsp_section_nocache_begin = .;
365                *(SORT_BY_ALIGNMENT (SORT_BY_NAME (.bsp_nocache*)))
366                bsp_section_nocache_end = .;
367        } > REGION_NOCACHE AT > REGION_NOCACHE_LOAD
368        bsp_section_nocache_size = bsp_section_nocache_end - bsp_section_nocache_begin;
369        bsp_section_nocache_load_begin = LOADADDR (.nocache);
370        bsp_section_nocache_load_end = bsp_section_nocache_load_begin + bsp_section_nocache_size;
371
372        .nocachenoload (NOLOAD) : ALIGN_WITH_INPUT {
373                bsp_section_nocachenoload_begin = .;
374                *(SORT_BY_ALIGNMENT (SORT_BY_NAME (.bsp_noload_nocache*)))
375                bsp_section_nocacheheap_begin = .;
376                . += ORIGIN (REGION_NOCACHE) + LENGTH (REGION_NOCACHE) - ABSOLUTE (.);
377                bsp_section_nocacheheap_end = .;
378                bsp_section_nocachenoload_end = .;
379        } > REGION_NOCACHE AT > REGION_NOCACHE
380        bsp_section_nocacheheap_size = bsp_section_nocacheheap_end - bsp_section_nocacheheap_begin;
381        bsp_section_nocachenoload_size = bsp_section_nocachenoload_end - bsp_section_nocachenoload_begin;
382
383        /* FIXME */
384        RamBase = ORIGIN (REGION_WORK);
385        RamSize = LENGTH (REGION_WORK);
386        WorkAreaBase = bsp_section_work_begin;
387        HeapSize = 0;
388
389        /* Stabs debugging sections.  */
390        .stab          0 : { *(.stab) }
391        .stabstr       0 : { *(.stabstr) }
392        .stab.excl     0 : { *(.stab.excl) }
393        .stab.exclstr  0 : { *(.stab.exclstr) }
394        .stab.index    0 : { *(.stab.index) }
395        .stab.indexstr 0 : { *(.stab.indexstr) }
396        .comment       0 : { *(.comment) }
397        /* DWARF debug sections.
398           Symbols in the DWARF debugging sections are relative to the beginning
399           of the section so we begin them at 0.  */
400        /* DWARF 1 */
401        .debug          0 : { *(.debug) }
402        .line           0 : { *(.line) }
403        /* GNU DWARF 1 extensions */
404        .debug_srcinfo  0 : { *(.debug_srcinfo) }
405        .debug_sfnames  0 : { *(.debug_sfnames) }
406        /* DWARF 1.1 and DWARF 2 */
407        .debug_aranges  0 : { *(.debug_aranges) }
408        .debug_pubnames 0 : { *(.debug_pubnames) }
409        /* DWARF 2 */
410        .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
411        .debug_abbrev   0 : { *(.debug_abbrev) }
412        .debug_line     0 : { *(.debug_line) }
413        .debug_frame    0 : { *(.debug_frame) }
414        .debug_str      0 : { *(.debug_str) }
415        .debug_loc      0 : { *(.debug_loc) }
416        .debug_macinfo  0 : { *(.debug_macinfo) }
417        /* SGI/MIPS DWARF 2 extensions */
418        .debug_weaknames 0 : { *(.debug_weaknames) }
419        .debug_funcnames 0 : { *(.debug_funcnames) }
420        .debug_typenames 0 : { *(.debug_typenames) }
421        .debug_varnames  0 : { *(.debug_varnames) }
422        /* DWARF 3 */
423        .debug_pubtypes 0 : { *(.debug_pubtypes) }
424        .debug_ranges   0 : { *(.debug_ranges) }
425        /* DWARF extension */
426        .debug_macro    0 : { *(.debug_macro) }
427        .ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
428        .note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
429        /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
430
431        /*
432         * This is a RTEMS specific section to catch all unexpected input
433         * sections.  In case you get an error like
434         *   "section `.unexpected_sections' will not fit in region
435         *   `UNEXPECTED_SECTIONS'"
436         * you have to figure out the offending input section and add it to the
437         * appropriate output section definition above.
438         */
439        .unexpected_sections : { *(*) } > UNEXPECTED_SECTIONS
440}
Note: See TracBrowser for help on using the repository browser.