1/*
2 * Copyright (c) 2023 HPMicro
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6ENTRY(_start)
7
8STACK_SIZE = _stack_size;
9HEAP_SIZE = _heap_size;
10
11MEMORY
12{
13    XPI0 (rx) : ORIGIN = 0x80000000, LENGTH = _flash_size
14    ILM (wx) : ORIGIN = 0x00000000, LENGTH = 128K
15    DLM (w) : ORIGIN = 0x00080000, LENGTH = 128K
16    AHB_SRAM (w) : ORIGIN = 0xf0400000, LENGTH = 32K
17}
18
19__nor_cfg_option_load_addr__ = ORIGIN(XPI0) + 0x400;
20__boot_header_load_addr__ = ORIGIN(XPI0) + 0x1000;
21__app_load_addr__ = ORIGIN(XPI0) + 0x3000;
22__boot_header_length__ = __boot_header_end__ - __boot_header_start__;
23__app_offset__ = __app_load_addr__ - __boot_header_load_addr__;
24
25
26SECTIONS
27{
28    .nor_cfg_option __nor_cfg_option_load_addr__ : {
29        KEEP(*(.nor_cfg_option))
30    } > XPI0
31
32    .boot_header __boot_header_load_addr__ : {
33        __boot_header_start__ = .;
34        KEEP(*(.boot_header))
35        KEEP(*(.fw_info_table))
36        KEEP(*(.dc_info))
37        __boot_header_end__ = .;
38    } > XPI0
39
40    .start __app_load_addr__ : {
41        . = ALIGN(8);
42        KEEP(*(.start))
43    } > XPI0
44
45    __vector_load_addr__ = ADDR(.start) + SIZEOF(.start);
46    .vectors ORIGIN(ILM) : AT(__vector_load_addr__) {
47        . = ALIGN(8);
48        __vector_ram_start__ = .;
49        KEEP(*(.vector_table))
50        KEEP(*(.isr_vector))
51        KEEP(*(.vector_s_table))
52        KEEP(*(.isr_s_vector))
53        . = ALIGN(8);
54        __vector_ram_end__ = .;
55    } > ILM
56
57    .text (__vector_load_addr__ + SIZEOF(.vectors)) : {
58        . = ALIGN(8);
59        *(.text)
60        *(.text*)
61        *(.rodata)
62        *(.rodata*)
63        *(.srodata)
64        *(.srodata*)
65
66        *(.hash)
67        *(.dyn*)
68        *(.gnu*)
69        *(.pl*)
70
71        KEEP (*(.init))
72        KEEP (*(.fini))
73
74        /* section information for usbh class */
75        . = ALIGN(8);
76        __usbh_class_info_start__ = .;
77        KEEP(*(.usbh_class_info))
78        __usbh_class_info_end__ = .;
79
80        /* RT-Thread related sections - Start */
81        /* section information for finsh shell */
82        . = ALIGN(4);
83        __fsymtab_start = .;
84        KEEP(*(FSymTab))
85        __fsymtab_end = .;
86        . = ALIGN(4);
87        __vsymtab_start = .;
88        KEEP(*(VSymTab))
89        __vsymtab_end = .;
90        . = ALIGN(4);
91
92        . = ALIGN(4);
93        __rt_init_start = .;
94        KEEP(*(SORT(.rti_fn*)))
95        __rt_init_end = .;
96        . = ALIGN(4);
97
98        /* section information for modules */
99        . = ALIGN(4);
100        __rtmsymtab_start = .;
101        KEEP(*(RTMSymTab))
102        __rtmsymtab_end = .;
103
104        /* RT-Thread related sections - end */
105        . = ALIGN(8);
106    } > XPI0
107
108    .eh_frame :
109    {
110        __eh_frame_start = .;
111        KEEP(*(.eh_frame))
112        __eh_frame_end = .;
113    }  > XPI0
114
115    .eh_frame_hdr :
116    {
117        KEEP(*(.eh_frame_hdr))
118    }  > XPI0
119    __eh_frame_hdr_start = SIZEOF(.eh_frame_hdr) > 0 ? ADDR(.eh_frame_hdr) : 0;
120    __eh_frame_hdr_end = SIZEOF(.eh_frame_hdr) > 0 ? . : 0;
121
122    .rel : {
123        KEEP(*(.rel*))
124    } > XPI0
125
126    PROVIDE (__etext = .);
127    PROVIDE (_etext = .);
128    PROVIDE (etext = .);
129
130    __data_load_addr__ = etext;
131    .data : AT(__data_load_addr__) {
132        . = ALIGN(8);
133        __data_start__ = .;
134        __global_pointer$ = . + 0x800;
135        *(.data)
136        *(.data*)
137        *(.sdata)
138        *(.sdata*)
139
140        KEEP(*(.jcr))
141        KEEP(*(.dynamic))
142        KEEP(*(.got*))
143        KEEP(*(.got))
144        KEEP(*(.gcc_except_table))
145        KEEP(*(.gcc_except_table.*))
146
147        . = ALIGN(8);
148        PROVIDE(__preinit_array_start = .);
149        KEEP(*(.preinit_array))
150        PROVIDE(__preinit_array_end = .);
151
152        . = ALIGN(8);
153        PROVIDE(__init_array_start = .);
154        KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*)))
155        KEEP(*(.init_array))
156        PROVIDE(__init_array_end = .);
157
158        . = ALIGN(8);
159        PROVIDE(__finit_array_start = .);
160        KEEP(*(SORT_BY_INIT_PRIORITY(.finit_array.*)))
161        KEEP(*(.finit_array))
162        PROVIDE(__finit_array_end = .);
163
164        . = ALIGN(8);
165        KEEP(*crtbegin*.o(.ctors))
166        KEEP(*(EXCLUDE_FILE (*crtend*.o) .ctors))
167        KEEP(*(SORT(.ctors.*)))
168        KEEP(*(.ctors))
169
170        . = ALIGN(8);
171        KEEP(*crtbegin*.o(.dtors))
172        KEEP(*(EXCLUDE_FILE (*crtend*.o) .dtors))
173        KEEP(*(SORT(.dtors.*)))
174        KEEP(*(.dtors))
175        . = ALIGN(8);
176        __data_end__ = .;
177        PROVIDE (__edata = .);
178        PROVIDE (_edata = .);
179        PROVIDE (edata = .);
180    } > DLM
181
182    __fast_load_addr__ = etext + SIZEOF(.data);
183    .fast : AT(__fast_load_addr__) {
184        . = ALIGN(8);
185        PROVIDE(__ramfunc_start__ = .);
186        *(.fast)
187        *(.fast.*)
188        . = ALIGN(8);
189        PROVIDE(__ramfunc_end__ = .);
190    } > ILM
191
192    .bss (NOLOAD) : {
193        . = ALIGN(8);
194        __bss_start__ = .;
195        *(.bss)
196        *(.bss*)
197        *(.sbss*)
198        *(.scommon)
199        *(.scommon*)
200        *(.dynsbss*)
201        *(COMMON)
202        . = ALIGN(8);
203        _end = .;
204        __bss_end__ = .;
205    } > DLM
206
207    __tdata_load_addr__ = etext + SIZEOF(.data) + SIZEOF(.fast);
208    .tdata : AT(__tdata_load_addr__) {
209        . = ALIGN(8);
210        PROVIDE(__tdata_start__ = .);
211        *(.tdata)
212        *(.tdata.*)
213        *(.gnu.linkonce.td.*)
214        . = ALIGN(8);
215        PROVIDE(__tdata_end__ = .);
216    } > DLM
217
218    .tbss (NOLOAD) : {
219        . = ALIGN(8);
220        PROVIDE(__tbss_start__ = .);
221        __thread_pointer$ = .;
222        *(.tbss)
223        *(.tbss.*)
224        *(.gnu.linkonce.tb.*)
225        *(.tcommon)
226        . = ALIGN(8);
227        PROVIDE(__tbss_end__ = .);
228    } > DLM
229
230    .framebuffer (NOLOAD) : {
231        . = ALIGN(8);
232        KEEP(*(.framebuffer))
233        . = ALIGN(8);
234    } > DLM
235
236    __noncacheable_init_load_addr__ = etext + SIZEOF(.data) + SIZEOF(.fast) + SIZEOF(.tdata);
237    .noncacheable.init : AT(__noncacheable_init_load_addr__) {
238        . = ALIGN(8);
239        __noncacheable_init_start__ = .;
240        KEEP(*(.noncacheable.init))
241        __noncacheable_init_end__ = .;
242        . = ALIGN(8);
243    } > DLM
244
245    .noncacheable.bss (NOLOAD) : {
246        . = ALIGN(8);
247        KEEP(*(.noncacheable))
248        __noncacheable_bss_start__ = .;
249        KEEP(*(.noncacheable.bss))
250        __noncacheable_bss_end__ = .;
251        . = ALIGN(8);
252    } > DLM
253
254    __fast_ram_init_load_addr__ = etext + SIZEOF(.data) + SIZEOF(.fast) + SIZEOF(.tdata) + SIZEOF(.noncacheable.init);
255    .fast_ram.init : AT(__fast_ram_init_load_addr__) {
256        . = ALIGN(8);
257        __fast_ram_init_start__ = .;
258        KEEP(*(.fast_ram.init))
259        __fast_ram_init_end__ = .;
260        . = ALIGN(8);
261    } > DLM
262
263    .ahb_sram (NOLOAD) : {
264        KEEP(*(.ahb_sram))
265    } > AHB_SRAM
266
267    .fast_ram.bss (NOLOAD) : {
268        . = ALIGN(8);
269        KEEP(*(.fast_ram))
270        __fast_ram_bss_start__ = .;
271        KEEP(*(.fast_ram.bss))
272        __fast_ram_bss_end__ = .;
273        . = ALIGN(8);
274    } > DLM
275
276    .heap (NOLOAD) : {
277        . = ALIGN(8);
278        __heap_start__ = .;
279        . += HEAP_SIZE;
280        __heap_end__ = .;
281    } > DLM
282
283    .stack (NOLOAD) : {
284        . = ALIGN(16);
285        __stack_base__ = .;
286        . += STACK_SIZE;
287        . = ALIGN(16);
288        PROVIDE (_stack = .);
289        PROVIDE (_stack_safe = .);
290    } > DLM
291
292    __fw_size__ = SIZEOF(.start) + SIZEOF(.vectors) + SIZEOF(.rel) + SIZEOF(.text) + SIZEOF(.data) + SIZEOF(.fast) + SIZEOF(.tdata) + SIZEOF(.noncacheable.init) + SIZEOF(.fast_ram.init);
293    __last_addr__ = __fast_ram_init_load_addr__ + SIZEOF(.fast_ram.init);
294    ASSERT(((__fw_size__ <= LENGTH(XPI0)) && (__last_addr__ <= (ORIGIN(XPI0) + LENGTH(XPI0)))), "******  FAILED! XPI0 has not enough space!  ******")
295}
296