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

5
Last change on this file since 9964895 was 9964895, checked in by Sebastian Huber <sebastian.huber@…>, on 04/20/18 at 08:35:35

bsps: Move startup files to bsps

Adjust build support files to new directory layout.

This patch is a part of the BSP source reorganization.

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