/*
 * Copyright 2022 hpmicro
 * SPDX-License-Identifier: BSD-3-Clause
 */


define memory with size = 4G;

/* Regions */
define region ILM = [from 0 size 128k]; /* ILM */
define region RAM   = [from 0x80000 size 128k];    /* DLM */
define region AXI_SRAM  = [from 0x1080000 size 256k];
define region NONCACHEABLE_RAM = [from 0x10C0000 size 256K];

define exported symbol __noncacheable_start__  = start of region NONCACHEABLE_RAM;
define exported symbol __noncacheable_end__  = end of region NONCACHEABLE_RAM + 1;
define exported symbol _stack = end of block stack + 1;
define block safe_stack with size = 512, readwrite access {};
define exported symbol _stack_safe = end of block safe_stack + 1;

/* Blocks */
define block vectors with fixed order       { section .vector_table, section .isr_vector };
define block vectors_s with fixed order     { section .vector_s_table, section .isr_s_vector };
define block ctors                          { section .ctors,     section .ctors.*, block with         alphabetical order { init_array } };
define block dtors                          { section .dtors,     section .dtors.*, block with reverse alphabetical order { fini_array } };
define block eh_frame                       { section .eh_frame,  section .eh_frame.* };
define block tbss                           { section .tbss,      section .tbss.*  };
define block tdata                          { section .tdata,     section .tdata.* };
define block tls                            { block tbss, block tdata };
define block tdata_load                     { copy of block tdata };
define block heap  with size = __HEAPSIZE__,  alignment = 8, /* fill =0x00, */ readwrite access { };
define block stack with size = __STACKSIZE__, alignment = 8, /* fill =0xCD, */ readwrite access { };
define block framebuffer { section .framebuffer };


do not initialize                           { section .noncacheable };
do not initialize                           { section .non_init, section .non_init.*, section .*.non_init, section .*.non_init.* };
do not initialize                           { section .no_init, section .no_init.*, section .*.no_init, section .*.no_init.* };   // Legacy sections, kept for backwards compatibility
do not initialize                           { section .noinit, section .noinit.*, section .*.noinit, section .*.noinit.* };       // Legacy sections, used by some SDKs/HALs

initialize by copy with packing=auto        { section .noncacheable.init };
initialize by copy with packing=none        { section .data, section .data.*, section .*.data, section .*.data.* };               // Static data sections
initialize by copy with packing=auto        { section .sdata, section .sdata.* };
initialize by copy with packing=auto        { section .fast, section .fast.*, section .*.fast, section .*.fast.* };               // "RAM Code" sections

initialize by symbol __SEGGER_init_heap     { block heap  };                                        // Init the heap if there is one
initialize by symbol __SEGGER_init_ctors    { block ctors };                                        // Call constructors for global objects which need to be constructed before reaching main (if any). Make sure this is done after setting up heap.

place at start of ILM                   { symbol _start };
place in ILM                            { block vectors, block vectors_s };                     // Vector table section
place in ILM with minimum size order    { block tdata_load,                                     // Thread-local-storage load image
                                              block ctors,                                          // Constructors block
                                              block dtors,                                          // Destructors block
                                              block eh_frame,                                       // Exception frames placed directly into flash overriding default placement (sections writable)
                                              readonly,                                             // Catch-all for readonly data (e.g. .rodata, .srodata) // It is intended placing RO here
                                              readexec                                              // Catch-all for (readonly) executable code (e.g. .text)
                                            };

//
// The GNU compiler creates these exception-related sections as writeable.
// Override the section header flag and make them readonly so they can be
// placed into flash.
//
define access readonly { section .gcc_except_table, section .gcc_except_table.* };
define access readonly { section .eh_frame, section .eh_frame.* };
define access readonly { section .sdata.DW.* };

/* Explicit placement in AXI_SRAM */
place in AXI_SRAM                               { block framebuffer };

place in RAM with auto order                { section .fast, section .fast.*,                       // "ramfunc" section
                                              block tls,                                            // Thread-local-storage block
                                              readwrite,                                            // Catch-all for initialized/uninitialized data sections (e.g. .data, .noinit)
                                              zeroinit,                                              // Catch-all for zero-initialized data sections (e.g. .bss)
                                            };
place in NONCACHEABLE_RAM                   { section .noncacheable, section .noncacheable.init, section .noncacheable.bss };
place in RAM                                { block heap };                                         // Heap reserved block
place at end of RAM                         { block stack, block safe_stack };                                        // Stack reserved block at the end