1/****************************************************************************************
2* @file map.txt
3*
4* @brief This file is the map file (gnuarm or armgcc).
5*
6* Copyright (C) BouffaloLab 2018
7*
8****************************************************************************************
9*/
10
11/* configure the CPU type */
12OUTPUT_ARCH( "riscv" )
13/* link with the standard c library */
14/*INPUT(-lc)*/
15/* link with the standard GCC library */
16/*INPUT(-lgcc)*/
17/* configure the entry point */
18ENTRY(__start)
19
20StackSize = 0x0400; /*  1KB */
21HeapSize  = 0x1000; /*  4KB */
22
23MEMORY
24{
25    fw_header_memory  (rx)  : ORIGIN = 0x23000000 - 0x1000, LENGTH = 4K
26    xip_memory  (rx)  : ORIGIN = 0x23000000, LENGTH = 1024K
27    itcm_memory (rx)  : ORIGIN = 0x22010000, LENGTH = 16K
28    dtcm_memory (rx)  : ORIGIN = 0x42014000, LENGTH = 48K
29    ram_memory  (!rx) : ORIGIN = 0x42020000, LENGTH = 176K
30}
31
32SECTIONS
33{
34    PROVIDE(__metal_chicken_bit = 0);
35
36    .fw_header :
37    {
38        KEEP(*(.fw_header))
39    } > fw_header_memory
40
41    .text :
42    {
43        . = ALIGN(4);
44        __text_code_start__ = .;
45
46        KEEP (*(SORT_NONE(.init)))
47        KEEP (*(SORT_NONE(.vector)))
48
49        *(.text)
50        *(.text.*)
51
52        /* section information for finsh shell */
53        . = ALIGN(4);
54        __fsymtab_start = .;
55        KEEP(*(FSymTab))
56        __fsymtab_end = .;
57        . = ALIGN(4);
58        __vsymtab_start = .;
59        KEEP(*(VSymTab))
60        __vsymtab_end = .;
61        . = ALIGN(4);
62
63        /* section information for modules */
64        . = ALIGN(4);
65        __rtmsymtab_start = .;
66        KEEP(*(RTMSymTab))
67        __rtmsymtab_end = .;
68
69        /* section information for initialization */
70        . = ALIGN(4);
71        __rt_init_start = .;
72        KEEP(*(SORT(.rti_fn*)))
73        __rt_init_end = .;
74
75        /*put .rodata**/
76        *(EXCLUDE_FILE( *bl602_glb*.o* \
77                        *bl602_pds*.o* \
78                        *bl602_common*.o* \
79                        *bl602_sf_cfg*.o* \
80                        *bl602_sf_cfg_ext*.o* \
81                        *bl602_sf_ctrl*.o* \
82                        *bl602_sflash*.o* \
83                        *bl602_sflash_ext*.o* \
84                        *bl602_xip_sflash*.o* \
85                        *bl602_xip_sflash_ext*.o* \
86                        *bl602_ef_ctrl*.o*) .rodata*)
87        *(.rodata)
88        *(.rodata.*)
89
90        *(.srodata)
91        *(.srodata.*)
92
93        . = ALIGN(4);
94        __text_code_end__ = .;
95
96    } > xip_memory
97
98    . = ALIGN(4);
99    __itcm_load_addr = .;
100
101    .itcm_region : AT (__itcm_load_addr)
102    {
103        . = ALIGN(4);
104        __tcm_code_start__ = .;
105
106        *(.tcm_code.*)
107        *(.tcm_const.*)
108        *(.sclock_rlt_code.*)
109        *(.sclock_rlt_const.*)
110
111        *bl602_glb*.o*(.rodata*)
112        *bl602_pds*.o*(.rodata*)
113        *bl602_common*.o*(.rodata*)
114        *bl602_sf_cfg*.o*(.rodata*)
115        *bl602_sf_cfg_ext*.o*(.rodata*)
116        *bl602_sf_ctrl*.o*(.rodata*)
117        *bl602_sflash*.o*(.rodata*)
118        *bl602_sflash_ext*.o*(.rodata*)
119        *bl602_xip_sflash*.o*(.rodata*)
120        *bl602_xip_sflash_ext*.o*(.rodata*)
121        *bl602_ef_ctrl*.o*(.rodata*)
122
123        . = ALIGN(4);
124        __tcm_code_end__ = .;
125    } > itcm_memory
126
127    __dtcm_load_addr = __itcm_load_addr + SIZEOF(.itcm_region);
128
129    .dtcm_region : AT (__dtcm_load_addr)
130    {
131        . = ALIGN(4);
132        __tcm_data_start__ = .;
133
134        *(.tcm_data)
135
136        . = ALIGN(4);
137        __tcm_data_end__ = .;
138    } > dtcm_memory
139
140
141    /* .heap_dummy section doesn't contains any symbols. It is only
142     * used for linker to calculate size of heap sections, and assign
143     * values to heap symbols later */
144    .heap_dummy (NOLOAD):
145    {
146        . = ALIGN(0x4);
147        . = . + HeapSize;
148        . = ALIGN(0x4);
149    } > dtcm_memory
150
151    _HeapBase = ORIGIN(dtcm_memory) + LENGTH(dtcm_memory) - StackSize - HeapSize;
152    _HeapSize = HeapSize;
153
154    /* Check if data + heap + stack exceeds RAM limit */
155    ASSERT(_HeapBase >= __tcm_data_end__, "region RAM overflowed with stack")
156
157    /*************************************************************************/
158    /* .stack_dummy section doesn't contains any symbols. It is only
159     * used for linker to calculate size of stack sections, and assign
160     * values to stack symbols later */
161    .stack_dummy (NOLOAD):
162    {
163        . = ALIGN(0x4);
164        . = . + StackSize;
165        . = ALIGN(0x4);
166    } > dtcm_memory
167
168    /* Set stack top to end of RAM, and stack limit move down by
169     * size of stack_dummy section */
170    __StackTop = ORIGIN(dtcm_memory) + LENGTH(dtcm_memory);
171    PROVIDE( __freertos_irq_stack_top = __StackTop);
172    PROVIDE( __rt_rvstack = . );
173    __StackLimit = __StackTop - SIZEOF(.stack_dummy);
174
175    /* Check if data + heap + stack exceeds RAM limit */
176    ASSERT(__StackLimit >= __tcm_data_end__, "region RAM overflowed with stack")
177    /*************************************************************************/
178
179    __ram_load_addr = __dtcm_load_addr + SIZEOF(.dtcm_region);
180
181    /* Data section */
182    RAM_DATA : AT (__ram_load_addr)
183    {
184        . = ALIGN(4);
185        __ram_data_start__ = .;
186
187        PROVIDE( __global_pointer$ = . + 0x800 );
188
189        *(.data)
190        *(.data.*)
191        *(.sdata)
192        *(.sdata.*)
193        *(.sdata2)
194        *(.sdata2.*)
195
196        *(.nocache_ram)
197
198        . = ALIGN(4);
199        __bflog_tags_start__ = .;
200        *(.bflog_tags_array)
201        . = ALIGN(4);
202        __bflog_tags_end__ = .;
203        __ram_data_end__ = .;
204    } > ram_memory
205
206    .bss (NOLOAD) :
207    {
208        . = ALIGN(4);
209        __bss_start__ = .;
210
211        *(.bss*)
212        *(.sbss*)
213        *(COMMON)
214
215        . = ALIGN(4);
216        __bss_end__ = .;
217    } > ram_memory
218
219    .noinit_data (NOLOAD) :
220    {
221        . = ALIGN(4);
222        __noinit_data_start__ = .;
223
224        *(.noinit_data*)
225        *(.nocache_noinit_ram)
226
227        . = ALIGN(4);
228        __noinit_data_end__ = .;
229    } > ram_memory
230
231    .heap (NOLOAD):
232    {
233        . = ALIGN(4);
234        __HeapBase = .;
235
236        /*__end__ = .;*/
237        /*end = __end__;*/
238        KEEP(*(.heap*))
239
240        . = ALIGN(4);
241        __HeapLimit = .;
242    } > ram_memory
243    __HeapLimit = ORIGIN(ram_memory) + LENGTH(ram_memory);
244
245}
246
247