mirror of https://github.com/ARMmbed/mbed-os.git
Merge pull request #9571 from mprse/fix_9523_rtos_less_issue
Update to 2-region model for HEAP and Stack Memorypull/9856/head
Cruz Monrreal
GitHub
commit
e1736cd06f
|
|
@ -0,0 +1,105 @@
|
|||
# RAM memory model update - Mbed OS
|
||||
|
||||
# Table of contents
|
||||
|
||||
1. [RAM memory model update - Mbed OS](#mbed-os-ram-memory-model).
|
||||
1. [Table of contents](#table-of-contents).
|
||||
1. [Revision history](#revision-history).
|
||||
1. [Introduction](#introduction).
|
||||
1. [Current RAM memory model](#current-ram-memory-model).
|
||||
1. [Proposed RAM memory model](#proposed-ram-memory-model).
|
||||
1. [Phases](#phases).
|
||||
1. Detailed Design (#detailed-design).
|
||||
1. [Tools and configuration changes](#tools-and-configuration-changes).
|
||||
|
||||
### Revision history
|
||||
|
||||
1.0 - A brief description of this version. For example, Initial revision - Author name - Date.
|
||||
**NOTE: You may also specify the Mbed OS version this revision of design document applies to.**
|
||||
1.1 - Added new section - Author name - Date.
|
||||
|
||||
# Introduction
|
||||
|
||||
### Current RAM memory model
|
||||
|
||||
Single memory space is shared between stack and heap memory, start address is fixed but the size of both regions varies based on application and usage runtime.
|
||||
Heap starts at the first address after the end of ZI growing up into higher memory address and stack starts at the last memory address of RAM growing downward into lower addresses.
|
||||
|
||||
+----------------------+ Stack Start (Last address of RAM)
|
||||
| ISR stack |
|
||||
| Main Stack(No RTOS) |
|
||||
| | |
|
||||
| V |
|
||||
+----------------------+
|
||||
| ^ |
|
||||
| | |
|
||||
| Heap |
|
||||
+----------------------+ HEAP Start
|
||||
| ZI |
|
||||
|(Idle, Timer and Main |
|
||||
| stack is in ZI for |
|
||||
| RTOS) |
|
||||
+----------------------+
|
||||
| |
|
||||
+----------------------+ First address of RAM
|
||||
|
||||
#### Drawbacks:
|
||||
1. Collisions between stack and heap are hard to detect and result in hardfault.
|
||||
1. Cannot check stack limit - In case of new ARM architecture stack limit registers are available to verify stack boundaries, but this feature cannot be used with dynamic stack size.
|
||||
1. Stack size unification cannot be achieved across various targets.
|
||||
1. GCC ARM: Memory allocator request memory at 4K boundary end of HEAP memory should be 4K aligned. Placing ISR stack (1K) after HEAP memory in case of RTOS, results in loss of 3K RAM memory
|
||||
1. Memory allocators do not support HEAP split into multiple banks, hence with single region memory model HEAP is used only till end of first bank.
|
||||
|
||||
### Proposed RAM memory model
|
||||
|
||||
2-region memory model for heap and stack. Defined boundaries for ISR stack memory. Heap memory can be dynamic (starts at end of ZI and ends at last RAM address) or with fix boundaries in separate RAM bank.
|
||||
|
||||
+----------------------+ Heap Ends (Last address of RAM)
|
||||
| ^ |
|
||||
| | |
|
||||
| Heap |
|
||||
+----------------------+ HEAP Start
|
||||
| ZI |
|
||||
|(Idle, Timer and Main |
|
||||
| stack is in ZI for |
|
||||
| RTOS) |
|
||||
+----------------------+Stack Ends
|
||||
| ISR stack |
|
||||
| Main Stack(No RTOS) |
|
||||
| | |
|
||||
| V |
|
||||
+----------------------+Stack Start
|
||||
| |
|
||||
+----------------------+ First address of RAM
|
||||
|
||||
#### Drawbacks:
|
||||
1. ISR Stack is not dynamic - This drawback is mainly for bare metal implementation (RTOS-less) where ISR and Main stack is same. With this limitation application writer should know if stack or heap will be usued more and tweaks the values accordingly.
|
||||
|
||||
# Phases:
|
||||
This feature will be implemented in different phases as follow:
|
||||
|
||||
Phase 1 (5.12 Release):
|
||||
1. Adopt 2-region memory model for Stack and Heap memory.
|
||||
1. Unify the stack size accross all targets (RTOS: ISR stack - 1K Main thread Stack - 4K; Bare Metal(No RTOS) ISR/Main Stack - 4K)
|
||||
|
||||
Phase 2:
|
||||
1. Heap memory to be dynamic and starts at the end of ZI growing up till end of RAM memory (In case of single RAM bank)
|
||||
Heap memory to be dynamic and assigned partial or full RAM bank in case of multiple RAM banks, based on calculation of other RAM regions.
|
||||
1. ISR Stack to be placed after vectors or before ZI memory section.
|
||||
|
||||
Note: Heap split support across multiple RAM banks, can also be achieved post this change.
|
||||
|
||||
# Detailed Design
|
||||
1. Update tools to set define `MBED_BOOT_STACK_SIZE` from target config option `target.boot-stack-size`
|
||||
1. Linker Scripts - Update linker scripts for ARM, IAR and GCC toolchain to use MBED_BOOT_STACK_SIZE define for standardizing size of ISR stack.
|
||||
1. Update __user_setup_stackheap() implementation to adopt 2-region RAM memory model.
|
||||
__user_setup_stackheap() works with systems where the application starts with a value of sp (r13) that is already correct. To make use of sp(stack base), implement __user_setup_stackheap() to set up r0 (heap base), r2 (heap limit), and r3 (stack limit) (for a two-region model) and return.
|
||||
Reference http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.kui0099a/armlib_cjagaaha.htm http://www.keil.com/support/man/docs/armlib/armlib_chr1359122863069.htm
|
||||
1. Modify _sbrk() implementation for GCC to use 2-region memory model
|
||||
|
||||
# Tools and configuration changes
|
||||
|
||||
1. Target config option "target.boot-stack-size" which is passed to the linker as the define "MBED_BOOT_STACK_SIZE" so the linker can adjust the stack accordingly.
|
||||
Boot stack size - the size of ISR and main stack will be 4K as default in targets.json for bare metal (non-RTOS) builds.
|
||||
Boot stack size - the size of ISR stack will be over-written as 1K in `rtos/mbed_lib.json` for RTOS builds.
|
||||
|
||||
|
|
@ -908,21 +908,44 @@ extern "C" long PREFIX(_flen)(FILEHANDLE fh)
|
|||
// Do not compile this code for TFM secure target
|
||||
#if !defined(COMPONENT_SPE) || !defined(TARGET_TFM)
|
||||
|
||||
extern "C" char Image$$RW_IRAM1$$ZI$$Limit[];
|
||||
#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
|
||||
__asm(".global __use_two_region_memory\n\t");
|
||||
__asm(".global __use_no_semihosting\n\t");
|
||||
|
||||
#else
|
||||
#pragma import(__use_two_region_memory)
|
||||
#endif
|
||||
|
||||
#if !defined(HEAP_START)
|
||||
// Heap here is considered starting after ZI ends to Stack start
|
||||
extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Base[];
|
||||
extern uint32_t Image$$RW_IRAM1$$ZI$$Limit[];
|
||||
#define HEAP_START Image$$RW_IRAM1$$ZI$$Limit
|
||||
#define HEAP_SIZE ((uint32_t)((uint32_t) Image$$ARM_LIB_STACK$$ZI$$Base - (uint32_t) HEAP_START))
|
||||
#endif
|
||||
|
||||
#define HEAP_LIMIT ((uint32_t)((uint32_t)HEAP_START + (uint32_t)HEAP_SIZE))
|
||||
|
||||
extern "C" MBED_WEAK __value_in_regs struct __initial_stackheap _mbed_user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3)
|
||||
{
|
||||
uint32_t zi_limit = (uint32_t)Image$$RW_IRAM1$$ZI$$Limit;
|
||||
uint32_t sp_limit = __current_sp();
|
||||
|
||||
zi_limit = (zi_limit + 7) & ~0x7; // ensure zi_limit is 8-byte aligned
|
||||
|
||||
uint32_t heap_base = (uint32_t)HEAP_START;
|
||||
struct __initial_stackheap r;
|
||||
r.heap_base = zi_limit;
|
||||
r.heap_limit = sp_limit;
|
||||
|
||||
// Ensure heap_base is 8-byte aligned
|
||||
heap_base = (heap_base + 7) & ~0x7;
|
||||
r.heap_base = (uint32_t)heap_base;
|
||||
r.heap_limit = (uint32_t)HEAP_LIMIT;
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
extern "C" __value_in_regs struct __argc_argv $Super$$__rt_lib_init(unsigned heapbase, unsigned heaptop);
|
||||
|
||||
extern "C" __value_in_regs struct __argc_argv $Sub$$__rt_lib_init(unsigned heapbase, unsigned heaptop)
|
||||
{
|
||||
return $Super$$__rt_lib_init((unsigned)HEAP_START, (unsigned)HEAP_LIMIT);
|
||||
}
|
||||
|
||||
extern "C" __value_in_regs struct __initial_stackheap __user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3)
|
||||
{
|
||||
return _mbed_user_setup_stackheap(R0, R1, R2, R3);
|
||||
|
|
@ -1211,46 +1234,22 @@ extern "C" WEAK void __cxa_pure_virtual(void)
|
|||
// SP. This make it compatible with RTX RTOS thread stacks.
|
||||
#if defined(TOOLCHAIN_GCC_ARM)
|
||||
|
||||
#if defined(TARGET_CORTEX_A) || (defined(TARGET_TFM) && defined(COMPONENT_SPE))
|
||||
extern "C" uint32_t __HeapLimit;
|
||||
#endif
|
||||
extern "C" uint32_t __end__;
|
||||
extern "C" uint32_t __HeapLimit;
|
||||
|
||||
// Turn off the errno macro and use actual global variable instead.
|
||||
#undef errno
|
||||
extern "C" int errno;
|
||||
|
||||
// Dynamic memory allocation related syscall.
|
||||
#if defined(TWO_RAM_REGIONS)
|
||||
|
||||
// Overwrite _sbrk() to support two region model (heap and stack are two distinct regions).
|
||||
// __wrap__sbrk() is implemented in:
|
||||
// TARGET_STM32L4 targets/TARGET_STM/TARGET_STM32L4/TARGET_STM32L4/l4_retarget.c
|
||||
extern "C" void *__wrap__sbrk(int incr);
|
||||
extern "C" caddr_t _sbrk(int incr)
|
||||
{
|
||||
return (caddr_t) __wrap__sbrk(incr);
|
||||
}
|
||||
#else
|
||||
// Linker defined symbol used by _sbrk to indicate where heap should start.
|
||||
extern "C" uint32_t __end__;
|
||||
// Weak attribute allows user to override, e.g. to use external RAM for dynamic memory.
|
||||
extern "C" WEAK caddr_t _sbrk(int incr)
|
||||
{
|
||||
static unsigned char *heap = (unsigned char *)&__end__;
|
||||
unsigned char *prev_heap = heap;
|
||||
unsigned char *new_heap = heap + incr;
|
||||
static uint32_t heap = (uint32_t) &__end__;
|
||||
uint32_t prev_heap = heap;
|
||||
uint32_t new_heap = heap + incr;
|
||||
|
||||
#if defined(TARGET_CORTEX_A) || (defined(TARGET_TFM) && defined(COMPONENT_SPE))
|
||||
if (new_heap >= (unsigned char *)&__HeapLimit) { /* __HeapLimit is end of heap section */
|
||||
#else
|
||||
if (new_heap >= (unsigned char *)__get_MSP()) {
|
||||
#endif
|
||||
errno = ENOMEM;
|
||||
return (caddr_t) -1;
|
||||
}
|
||||
|
||||
// Additional heap checking if set
|
||||
if (mbed_heap_size && (new_heap >= mbed_heap_start + mbed_heap_size)) {
|
||||
/* __HeapLimit is end of heap section */
|
||||
if (new_heap > (uint32_t) &__HeapLimit) {
|
||||
errno = ENOMEM;
|
||||
return (caddr_t) -1;
|
||||
}
|
||||
|
|
@ -1259,7 +1258,6 @@ extern "C" WEAK caddr_t _sbrk(int incr)
|
|||
return (caddr_t) prev_heap;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(TOOLCHAIN_GCC_ARM)
|
||||
extern "C" void _exit(int return_code)
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ void mbed_copy_nvic(void)
|
|||
|
||||
/* Toolchain specific main code */
|
||||
|
||||
#if defined (__CC_ARM) || (defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 5010060))
|
||||
#if defined (__ARMCC_VERSION)
|
||||
|
||||
int $Super$$main(void);
|
||||
|
||||
|
|
|
|||
|
|
@ -27,18 +27,14 @@
|
|||
__value_in_regs struct __argc_argv __rt_lib_init(unsigned heapbase, unsigned heaptop);
|
||||
void _platform_post_stackheap_init(void);
|
||||
|
||||
#if !defined(ISR_STACK_SIZE)
|
||||
extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Base[];
|
||||
extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Length[];
|
||||
#define ISR_STACK_START ((unsigned char*)Image$$ARM_LIB_STACK$$ZI$$Base)
|
||||
#define ISR_STACK_SIZE ((uint32_t)Image$$ARM_LIB_STACK$$ZI$$Length)
|
||||
#endif
|
||||
|
||||
#if !defined(HEAP_START)
|
||||
/* Defined by linker script */
|
||||
extern uint32_t Image$$RW_IRAM1$$ZI$$Limit[];
|
||||
#define HEAP_START ((unsigned char*)Image$$RW_IRAM1$$ZI$$Limit)
|
||||
#define HEAP_SIZE ((uint32_t)((uint32_t)ISR_STACK_START - (uint32_t)HEAP_START))
|
||||
// Heap here is considered starting after ZI ends to Stack start
|
||||
extern uint32_t Image$$RW_IRAM1$$ZI$$Limit[];
|
||||
#define HEAP_START Image$$RW_IRAM1$$ZI$$Limit
|
||||
#define HEAP_SIZE ((uint32_t)((uint32_t)Image$$ARM_LIB_STACK$$ZI$$Base - (uint32_t)HEAP_START))
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
|
@ -58,23 +54,11 @@ extern uint32_t Image$$RW_IRAM1$$ZI$$Limit[];
|
|||
*/
|
||||
void __rt_entry(void)
|
||||
{
|
||||
unsigned char *free_start = HEAP_START;
|
||||
uint32_t free_size = HEAP_SIZE;
|
||||
mbed_stack_isr_start = (unsigned char *) Image$$ARM_LIB_STACK$$ZI$$Base;
|
||||
mbed_stack_isr_size = (uint32_t) Image$$ARM_LIB_STACK$$ZI$$Length;
|
||||
mbed_heap_start = (unsigned char *) HEAP_START;
|
||||
mbed_heap_size = (uint32_t) HEAP_SIZE;
|
||||
|
||||
#ifdef ISR_STACK_START
|
||||
/* Interrupt stack explicitly specified */
|
||||
mbed_stack_isr_size = ISR_STACK_SIZE;
|
||||
mbed_stack_isr_start = ISR_STACK_START;
|
||||
#else
|
||||
/* Interrupt stack - reserve space at the end of the free block */
|
||||
mbed_stack_isr_size = ISR_STACK_SIZE < free_size ? ISR_STACK_SIZE : free_size;
|
||||
mbed_stack_isr_start = free_start + free_size - mbed_stack_isr_size;
|
||||
free_size -= mbed_stack_isr_size;
|
||||
#endif
|
||||
|
||||
/* Heap - everything else */
|
||||
mbed_heap_size = free_size;
|
||||
mbed_heap_start = free_start;
|
||||
mbed_init();
|
||||
|
||||
_platform_post_stackheap_init();
|
||||
|
|
|
|||
|
|
@ -29,19 +29,10 @@ static osMutexId_t env_mutex_id;
|
|||
static mbed_rtos_storage_mutex_t env_mutex_obj;
|
||||
static osMutexAttr_t env_mutex_attr;
|
||||
|
||||
#if !defined(ISR_STACK_SIZE)
|
||||
extern uint32_t __StackLimit;
|
||||
extern uint32_t __StackTop;
|
||||
#define ISR_STACK_START ((unsigned char*)&__StackLimit)
|
||||
#define ISR_STACK_SIZE ((uint32_t)((uint32_t)&__StackTop - (uint32_t)&__StackLimit))
|
||||
#endif
|
||||
|
||||
#if !defined(HEAP_START)
|
||||
/* Defined by linker script */
|
||||
extern uint32_t __end__[];
|
||||
#define HEAP_START ((unsigned char*)__end__)
|
||||
#define HEAP_SIZE ((uint32_t)((uint32_t)ISR_STACK_START - (uint32_t)HEAP_START))
|
||||
#endif
|
||||
extern uint32_t __StackLimit;
|
||||
extern uint32_t __StackTop;
|
||||
extern uint32_t __end__;
|
||||
extern uint32_t __HeapLimit;
|
||||
|
||||
extern void __libc_init_array(void);
|
||||
|
||||
|
|
@ -52,24 +43,10 @@ extern void __libc_init_array(void);
|
|||
*/
|
||||
void software_init_hook(void)
|
||||
{
|
||||
unsigned char *free_start = HEAP_START;
|
||||
uint32_t free_size = HEAP_SIZE;
|
||||
|
||||
#ifdef ISR_STACK_START
|
||||
/* Interrupt stack explicitly specified */
|
||||
mbed_stack_isr_size = ISR_STACK_SIZE;
|
||||
mbed_stack_isr_start = ISR_STACK_START;
|
||||
#else
|
||||
/* Interrupt stack - reserve space at the end of the free block */
|
||||
mbed_stack_isr_size = ISR_STACK_SIZE < free_size ? ISR_STACK_SIZE : free_size;
|
||||
mbed_stack_isr_start = free_start + free_size - mbed_stack_isr_size;
|
||||
free_size -= mbed_stack_isr_size;
|
||||
#endif
|
||||
|
||||
/* Heap - everything else */
|
||||
mbed_heap_size = free_size;
|
||||
mbed_heap_start = free_start;
|
||||
|
||||
mbed_stack_isr_start = (unsigned char *) &__StackLimit;
|
||||
mbed_stack_isr_size = (uint32_t) &__StackTop - (uint32_t) &__StackLimit;
|
||||
mbed_heap_start = (unsigned char *) &__end__;
|
||||
mbed_heap_size = (uint32_t) &__HeapLimit - (uint32_t) &__end__;
|
||||
|
||||
mbed_init();
|
||||
mbed_rtos_start();
|
||||
|
|
|
|||
|
|
@ -40,34 +40,18 @@
|
|||
* Memory layout notes:
|
||||
* ====================
|
||||
*
|
||||
* IAR Default Memory layout notes:
|
||||
* -Heap defined by "HEAP" region in .icf file
|
||||
* -Interrupt stack defined by "CSTACK" region in .icf file
|
||||
* -Value INITIAL_SP is ignored
|
||||
* IAR Memory layout :
|
||||
* - Heap defined by "HEAP" region in .icf file
|
||||
* - Interrupt stack defined by "CSTACK" region in .icf file
|
||||
* - Value INITIAL_SP is ignored
|
||||
*
|
||||
* IAR Custom Memory layout notes:
|
||||
* -There is no custom layout available for IAR - everything must be defined in
|
||||
* the .icf file and use the default layout
|
||||
* GCC Memory layout :
|
||||
* - Heap explicitly placed in linker script (*.ld file) and heap start (__end___) and heap end (__HeapLimit) should be defined in linker script
|
||||
* - Interrupt stack placed in linker script **.ld file) and stack start (__StackTop) and stack end (__StackLimit) should be defined in linker script
|
||||
*
|
||||
*
|
||||
* GCC Default Memory layout notes:
|
||||
* -Block of memory from symbol __end__ to define INITIAL_SP used to setup interrupt
|
||||
* stack and heap in the function set_stack_heap()
|
||||
* -ISR_STACK_SIZE can be overridden to be larger or smaller
|
||||
*
|
||||
* GCC Custom Memory layout notes:
|
||||
* -Heap can be explicitly placed by defining both HEAP_START and HEAP_SIZE
|
||||
* -Interrupt stack can be explicitly placed by defining both ISR_STACK_START and ISR_STACK_SIZE
|
||||
*
|
||||
*
|
||||
* ARM Memory layout
|
||||
* -Block of memory from end of region "RW_IRAM1" to define INITIAL_SP used to setup interrupt
|
||||
* stack and heap in the function set_stack_heap()
|
||||
* -ISR_STACK_SIZE can be overridden to be larger or smaller
|
||||
*
|
||||
* ARM Custom Memory layout notes:
|
||||
* -Heap can be explicitly placed by defining both HEAP_START and HEAP_SIZE
|
||||
* -Interrupt stack can be explicitly placed by defining both ISR_STACK_START and ISR_STACK_SIZE
|
||||
* ARM Memory layout :
|
||||
* - Heap can be explicitly placed by adding ARM_LIB_HEAP section in scatter file and defining both HEAP_START and HEAP_SIZE
|
||||
* - Interrupt stack placed in scatter files (*.sct) by adding ARM_LIB_STACK section
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
|
|||
|
|
@ -202,6 +202,7 @@ SECTIONS
|
|||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > RAM
|
||||
|
|
|
|||
|
|
@ -202,6 +202,7 @@ SECTIONS
|
|||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > RAM
|
||||
|
|
|
|||
|
|
@ -202,6 +202,7 @@ SECTIONS
|
|||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > RAM
|
||||
|
|
|
|||
|
|
@ -202,6 +202,7 @@ SECTIONS
|
|||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > RAM
|
||||
|
|
|
|||
|
|
@ -202,6 +202,7 @@ SECTIONS
|
|||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > RAM
|
||||
|
|
|
|||
|
|
@ -24,7 +24,6 @@
|
|||
#define INITIAL_SP (ZBT_SRAM2_START + ZBT_SRAM2_SIZE)
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* defined(TARGET_...) */
|
||||
|
||||
#endif /* MBED_MBED_RTX_H */
|
||||
|
|
|
|||
|
|
@ -105,6 +105,7 @@ MEMORY {
|
|||
. = ALIGN(8);
|
||||
__end__ = . ;
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
/* stack section */
|
||||
|
|
|
|||
|
|
@ -105,6 +105,7 @@ MEMORY {
|
|||
. = ALIGN(8);
|
||||
__end__ = . ;
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
/* stack section */
|
||||
|
|
|
|||
|
|
@ -105,6 +105,7 @@ MEMORY {
|
|||
. = ALIGN(8);
|
||||
__end__ = . ;
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
/* stack section */
|
||||
|
|
|
|||
|
|
@ -105,6 +105,7 @@ MEMORY {
|
|||
. = ALIGN(8);
|
||||
__end__ = . ;
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
/* stack section */
|
||||
|
|
|
|||
|
|
@ -105,6 +105,7 @@ MEMORY {
|
|||
. = ALIGN(8);
|
||||
__end__ = . ;
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
/* stack section */
|
||||
|
|
|
|||
|
|
@ -314,6 +314,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
KEEP(*(.heap*))
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
|
|
|
|||
|
|
@ -314,6 +314,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
KEEP(*(.heap*))
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
|
|
|
|||
|
|
@ -314,6 +314,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
KEEP(*(.heap*))
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
|
|
|
|||
|
|
@ -314,6 +314,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
KEEP(*(.heap*))
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
|
|
|
|||
|
|
@ -314,6 +314,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
KEEP(*(.heap*))
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
|
|
|
|||
|
|
@ -297,6 +297,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
KEEP(*(.heap*))
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
|
|
|
|||
|
|
@ -295,6 +295,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
KEEP(*(.heap*))
|
||||
. = ORIGIN(ram) + LENGTH(ram) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > ram
|
||||
|
||||
|
|
|
|||
|
|
@ -14,10 +14,14 @@ LR_IROM1 0x00000000 0x20000 { ; load region size_region (132k)
|
|||
}
|
||||
; 8_byte_aligned(62 vect * 4 bytes) = 8_byte_aligned(0xF8) = 0xF8
|
||||
; 0x4000 - 0xF8 = 0x3F08
|
||||
RW_IRAM1 0x1FFFE0F8 0x3F08-Stack_Size {
|
||||
RW_IRAM1 0x1FFFE0F8 0x3F08 {
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
ARM_LIB_STACK 0x1FFFE0F8+0x3F08 EMPTY -Stack_Size { ; Stack region growing down
|
||||
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (0x1FFFE000+0x4000-Stack_Size-AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
|
||||
ARM_LIB_STACK 0x1FFFE000+0x4000 EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -147,6 +147,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -14,9 +14,13 @@ LR_IROM1 0x00000000 0x40000 { ; load region size_region (256k)
|
|||
}
|
||||
; 8_byte_aligned(112 vect * 4 bytes) = 8_byte_aligned(0x1C0) = 0x1C0
|
||||
; 0x10000 - 0x1C0 = 0xFE40
|
||||
RW_IRAM1 0x1FFF81C0 0xFE40-Stack_Size {
|
||||
RW_IRAM1 0x1FFF81C0 0xFE40 {
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
ARM_LIB_STACK 0x1FFF81C0+0xFE40 EMPTY -Stack_Size { ; Stack region growing down
|
||||
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (0x1FFF8000+0x10000-Stack_Size-AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
|
||||
ARM_LIB_STACK 0x1FFF8000+0x10000 EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -148,6 +148,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -14,9 +14,13 @@ LR_IROM1 0x00000000 0x8000 { ; load region size_region (32k)
|
|||
}
|
||||
; 8_byte_aligned(48 vect * 4 bytes) = 8_byte_aligned(0xC0) = 0xC0
|
||||
; 0x1000 - 0xC0 = 0xF40
|
||||
RW_IRAM1 0x1FFFFCC0 0xF40-Stack_Size {
|
||||
RW_IRAM1 0x1FFFF000 0xF40 {
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
ARM_LIB_STACK 0x1FFFFCC0+0xF40 EMPTY -Stack_Size { ; Stack region growing down
|
||||
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (0x1FFFF000+0x1000-Stack_Size-AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
|
||||
ARM_LIB_STACK 0x1FFFF000+0x1000 EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -138,6 +138,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
.= ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -12,12 +12,17 @@ LR_IROM1 0x00000000 0x20000 { ; load region size_region (32k)
|
|||
*(InRoot$$Sections)
|
||||
.ANY (+RO)
|
||||
}
|
||||
|
||||
; 8_byte_aligned(48 vect * 4 bytes) = 8_byte_aligned(0xC0) = 0xC0
|
||||
; 0x4000 - 0xC0 = 0x3F40
|
||||
RW_IRAM1 0x1FFFF0C0 0x3F40-Stack_Size {
|
||||
RW_IRAM1 0x1FFFF0C0 0x3F40 {
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
ARM_LIB_STACK 0x1FFFF0C0+0x3F40 EMPTY -Stack_Size { ; Stack region growing down
|
||||
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (0x1FFFF000+0x4000-Stack_Size-AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
|
||||
ARM_LIB_STACK 0x1FFFF000+0x4000 EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -147,6 +147,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -147,6 +147,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -14,10 +14,14 @@ LR_IROM1 0x00000000 0x40000 { ; load region size_region (256k)
|
|||
}
|
||||
; 8_byte_aligned(48 vect * 4 bytes) = 8_byte_aligned(0xC0) = 0xC0
|
||||
; 0x8000 - 0xC0 = 0x7F40
|
||||
RW_IRAM1 0x1FFFE0C0 0x7F40-Stack_Size {
|
||||
RW_IRAM1 0x1FFFE0C0 0x7F40 {
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
ARM_LIB_STACK 0x1FFFE0C0+0x7F40 EMPTY -Stack_Size { ; Stack region growing down
|
||||
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (0x1FFFE000+0x8000-Stack_Size-AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
|
||||
ARM_LIB_STACK 0x1FFFE000+0x8000 EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -147,6 +147,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -92,12 +92,6 @@
|
|||
#define Stack_Size MBED_BOOT_STACK_SIZE
|
||||
#endif
|
||||
|
||||
#if (defined(__heap_size__))
|
||||
#define Heap_Size __heap_size__
|
||||
#else
|
||||
#define Heap_Size 0x0400
|
||||
#endif
|
||||
|
||||
LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load region size_region
|
||||
VECTOR_ROM m_interrupts_start m_interrupts_size { ; load address = execution address
|
||||
* (RESET,+FIRST)
|
||||
|
|
@ -122,10 +116,12 @@ LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; lo
|
|||
RW_m_data m_data_start m_data_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_m_data_2 m_data_2_start m_data_2_size-Stack_Size-Heap_Size { ; RW data
|
||||
RW_m_data_2 m_data_2_start m_data_2_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) { ; Heap region growing up
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_2_start + m_data_2_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_2_start+m_data_2_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,8 +57,6 @@ __ram_vector_table__ = 1;
|
|||
* the stack where main runs is determined via the RTOS. */
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
|
||||
__heap_size__ = 0x6000;
|
||||
|
||||
#if !defined(MBED_APP_START)
|
||||
#define MBED_APP_START 0
|
||||
#endif
|
||||
|
|
@ -67,7 +65,6 @@ __heap_size__ = 0x6000;
|
|||
#define MBED_APP_SIZE 0x200000
|
||||
#endif
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x0400 : 0x0;
|
||||
M_CRASH_DATA_RAM_SIZE = 0x100;
|
||||
|
|
@ -253,7 +250,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data_2) + LENGTH(m_data_2) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data_2
|
||||
|
|
|
|||
|
|
@ -119,10 +119,12 @@ LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load
|
|||
RW_m_data m_data_start m_data_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_m_data_2 m_data_2_start m_data_2_size-Stack_Size-Heap_Size { ; RW data
|
||||
RW_m_data_2 m_data_2_start m_data_2_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) { ; Heap region growing up
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_2_start + m_data_2_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_2_start+m_data_2_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,9 +60,6 @@ __ram_vector_table__ = 1;
|
|||
* the stack where main runs is determined via the RTOS. */
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
|
||||
__heap_size__ = 0x6000;
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x03C0 : 0x0;
|
||||
|
||||
|
|
@ -247,7 +244,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data_2) + LENGTH(m_data_2) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data_2
|
||||
|
|
|
|||
|
|
@ -82,12 +82,6 @@
|
|||
#define Stack_Size MBED_BOOT_STACK_SIZE
|
||||
#endif
|
||||
|
||||
#if (defined(__heap_size__))
|
||||
#define Heap_Size __heap_size__
|
||||
#else
|
||||
#define Heap_Size 0x0400
|
||||
#endif
|
||||
|
||||
LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load region size_region
|
||||
VECTOR_ROM m_interrupts_start m_interrupts_size { ; load address = execution address
|
||||
* (RESET,+FIRST)
|
||||
|
|
@ -107,10 +101,12 @@ LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; lo
|
|||
VECTOR_RAM m_interrupts_start EMPTY 0 {
|
||||
}
|
||||
#endif
|
||||
RW_m_data m_data_start m_data_size-Stack_Size-Heap_Size { ; RW data
|
||||
RW_m_data m_data_start m_data_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 +0 { ; Heap region growing up
|
||||
RW_IRAM1 +0 {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_start + m_data_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_start+m_data_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,13 +57,8 @@ __ram_vector_table__ = 1;
|
|||
#define MBED_BOOT_STACK_SIZE 0x400
|
||||
#endif
|
||||
|
||||
/* With the RTOS in use, this does not affect the main stack size. The size of
|
||||
* the stack where main runs is determined via the RTOS. */
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
/* With the RTOS in use, this does not affect the main heap size. */
|
||||
__heap_size__ = 0x0;
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x0200 : 0x0;
|
||||
|
||||
|
|
@ -249,7 +244,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data) + LENGTH(m_data) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data
|
||||
|
|
|
|||
|
|
@ -80,12 +80,6 @@
|
|||
#define Stack_Size MBED_BOOT_STACK_SIZE
|
||||
#endif
|
||||
|
||||
#if (defined(__heap_size__))
|
||||
#define Heap_Size __heap_size__
|
||||
#else
|
||||
#define Heap_Size 0x0400
|
||||
#endif
|
||||
|
||||
LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load region size_region
|
||||
VECTOR_ROM m_interrupts_start m_interrupts_size { ; load address = execution address
|
||||
* (RESET,+FIRST)
|
||||
|
|
@ -105,10 +99,12 @@ LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load
|
|||
VECTOR_RAM m_interrupts_start EMPTY 0 {
|
||||
}
|
||||
#endif
|
||||
RW_m_data m_data_start m_data_size-Stack_Size-Heap_Size { ; RW data
|
||||
RW_m_data m_data_start m_data_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 +0 { ; Heap region growing up
|
||||
RW_IRAM1 +0 {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_start + m_data_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_start+m_data_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,9 +58,6 @@ __ram_vector_table__ = 1;
|
|||
* the stack where main runs is determined via the RTOS. */
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
|
||||
__heap_size__ = 0x2800;
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x0200 : 0x0;
|
||||
|
||||
|
|
@ -246,7 +243,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data) + LENGTH(m_data) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data
|
||||
|
|
|
|||
|
|
@ -92,12 +92,6 @@
|
|||
#define Stack_Size MBED_BOOT_STACK_SIZE
|
||||
#endif
|
||||
|
||||
#if (defined(__heap_size__))
|
||||
#define Heap_Size __heap_size__
|
||||
#else
|
||||
#define Heap_Size 0x0400
|
||||
#endif
|
||||
|
||||
LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load region size_region
|
||||
VECTOR_ROM m_interrupts_start m_interrupts_size { ; load address = execution address
|
||||
* (RESET,+FIRST)
|
||||
|
|
@ -120,10 +114,12 @@ LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load
|
|||
VECTOR_RAM m_interrupts_start EMPTY 0 {
|
||||
}
|
||||
#endif
|
||||
RW_m_data m_data_start m_data_size-Stack_Size-Heap_Size { ; RW data
|
||||
RW_m_data m_data_start m_data_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 +0 { ; Heap region growing up
|
||||
RW_IRAM1 +0 {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_start + m_data_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_start+m_data_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
|
|
|
|||
|
|
@ -61,9 +61,6 @@ __ram_vector_table__ = 1;
|
|||
* the stack where main runs is determined via the RTOS. */
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
|
||||
__heap_size__ = 0x6000;
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x0140 : 0x0;
|
||||
|
||||
|
|
@ -258,7 +255,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data) + LENGTH(m_data) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data
|
||||
|
|
|
|||
|
|
@ -88,12 +88,6 @@
|
|||
#define Stack_Size MBED_BOOT_STACK_SIZE
|
||||
#endif
|
||||
|
||||
#if (defined(__heap_size__))
|
||||
#define Heap_Size __heap_size__
|
||||
#else
|
||||
#define Heap_Size 0x0400
|
||||
#endif
|
||||
|
||||
LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load region size_region
|
||||
VECTOR_ROM m_interrupts_start m_interrupts_size { ; load address = execution address
|
||||
* (RESET,+FIRST)
|
||||
|
|
@ -116,10 +110,12 @@ LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load
|
|||
RW_m_data m_data_start m_data_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_m_data_2 m_data_2_start m_data_2_size-Stack_Size-Heap_Size { ; RW data
|
||||
RW_m_data_2 m_data_2_start m_data_2_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) { ; Heap region growing up
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_2_start + m_data_2_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_2_start+m_data_2_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
|
|
|
|||
|
|
@ -56,8 +56,6 @@ __ram_vector_table__ = 1;
|
|||
* the stack where main runs is determined via the RTOS. */
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
|
||||
__heap_size__ = 0x4000;
|
||||
|
||||
#if !defined(MBED_APP_START)
|
||||
#define MBED_APP_START 0
|
||||
#endif
|
||||
|
|
@ -66,7 +64,6 @@ __heap_size__ = 0x4000;
|
|||
#define MBED_APP_SIZE 0x80000
|
||||
#endif
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x0400 : 0x0;
|
||||
|
||||
|
|
@ -243,7 +240,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data_2) + LENGTH(m_data_2) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data_2
|
||||
|
|
|
|||
|
|
@ -85,12 +85,6 @@
|
|||
#define Stack_Size MBED_BOOT_STACK_SIZE
|
||||
#endif
|
||||
|
||||
#if (defined(__heap_size__))
|
||||
#define Heap_Size __heap_size__
|
||||
#else
|
||||
#define Heap_Size 0x0400
|
||||
#endif
|
||||
|
||||
LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load region size_region
|
||||
VECTOR_ROM m_interrupts_start m_interrupts_size { ; load address = execution address
|
||||
* (RESET,+FIRST)
|
||||
|
|
@ -110,10 +104,12 @@ LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load
|
|||
VECTOR_RAM m_interrupts_start EMPTY 0 {
|
||||
}
|
||||
#endif
|
||||
RW_m_data m_data_start m_data_size-Stack_Size-Heap_Size { ; RW data
|
||||
RW_m_data m_data_start m_data_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 +0 { ; Heap region growing up
|
||||
RW_IRAM1 +0 {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_start + m_data_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_start+m_data_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,13 +60,8 @@ __ram_vector_table__ = 1;
|
|||
#define MBED_BOOT_STACK_SIZE 0x400
|
||||
#endif
|
||||
|
||||
/* With the RTOS in use, this does not affect the main stack size. The size of
|
||||
* the stack where main runs is determined via the RTOS. */
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
|
||||
__heap_size__ = 0x6000;
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x0200 : 0x0;
|
||||
|
||||
|
|
@ -248,7 +243,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data) + LENGTH(m_data) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data
|
||||
|
|
|
|||
|
|
@ -86,12 +86,6 @@
|
|||
#define Stack_Size MBED_BOOT_STACK_SIZE
|
||||
#endif
|
||||
|
||||
#if (defined(__heap_size__))
|
||||
#define Heap_Size __heap_size__
|
||||
#else
|
||||
#define Heap_Size 0x0400
|
||||
#endif
|
||||
|
||||
LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load region size_region
|
||||
VECTOR_ROM m_interrupts_start m_interrupts_size { ; load address = execution address
|
||||
* (RESET,+FIRST)
|
||||
|
|
@ -114,12 +108,13 @@ LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; lo
|
|||
RW_m_data m_data_start m_data_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_m_data_2 m_data_2_start m_data_2_size-Stack_Size-Heap_Size { ; RW data
|
||||
RW_m_data_2 m_data_2_start m_data_2_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) { ; Heap region growing up
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_2_start + m_data_2_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_2_start+m_data_2_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -60,9 +60,6 @@ ENTRY(Reset_Handler)
|
|||
__ram_vector_table__ = 1;
|
||||
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
__heap_size__ = 0x8000;
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x0400 : 0x0;
|
||||
|
||||
|
|
@ -239,7 +236,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data_2) + LENGTH(m_data_2) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data_2
|
||||
|
|
|
|||
|
|
@ -104,13 +104,23 @@ LR_IROM1 m_interrupts_start m_text_size+m_interrupts_size+m_flash_config_size {
|
|||
* (InRoot$$Sections)
|
||||
.ANY (+RO)
|
||||
}
|
||||
|
||||
#if (defined(__ram_vector_table__))
|
||||
VECTOR_RAM m_interrupts_ram_start EMPTY m_interrupts_ram_size {
|
||||
}
|
||||
#else
|
||||
VECTOR_RAM m_interrupts_start EMPTY 0 {
|
||||
}
|
||||
#endif
|
||||
RW_m_data m_data_start m_data_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 m_data_2_start m_data_2_size-Stack_Size { ; RW data
|
||||
RW_m_data_2 m_data_2_start m_data_2_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
VECTOR_RAM m_interrupts_ram_start EMPTY m_interrupts_ram_size {
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_2_start + m_data_2_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_2_start+m_data_2_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,7 +57,6 @@ ENTRY(Reset_Handler)
|
|||
__ram_vector_table__ = 1;
|
||||
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
__heap_size__ = 0x10000;
|
||||
|
||||
#if !defined(MBED_APP_START)
|
||||
#define MBED_APP_START 0
|
||||
|
|
@ -67,7 +66,6 @@ __heap_size__ = 0x10000;
|
|||
#define MBED_APP_SIZE 0x100000
|
||||
#endif
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x8000;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x10000;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x0400 : 0x0;
|
||||
|
||||
|
|
@ -258,7 +256,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data_2) + LENGTH(m_data_2) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data_2
|
||||
|
|
|
|||
|
|
@ -96,13 +96,7 @@
|
|||
#define Stack_Size MBED_BOOT_STACK_SIZE
|
||||
#endif
|
||||
|
||||
#if (defined(__heap_size__))
|
||||
#define Heap_Size __heap_size__
|
||||
#else
|
||||
#define Heap_Size 0x0400
|
||||
#endif
|
||||
|
||||
LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load region size_region
|
||||
LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; load region size_region
|
||||
VECTOR_ROM m_interrupts_start m_interrupts_size { ; load address = execution address
|
||||
* (RESET,+FIRST)
|
||||
}
|
||||
|
|
@ -129,9 +123,9 @@ LR_IROM1 m_interrupts_start m_text_start+m_text_size-m_interrupts_start { ; lo
|
|||
RW_m_data_2 m_data_2_start m_data_2_size { ; RW data
|
||||
.ANY (+RW +ZI)
|
||||
}
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) { ; Heap region growing up
|
||||
RW_IRAM1 ImageLimit(RW_m_data_2) {
|
||||
}
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_2_start + m_data_2_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) {
|
||||
ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (m_data_2_start + m_data_2_size - Stack_Size - AlignExpr(ImageLimit(RW_IRAM1), 16)) { ; Heap region growing up
|
||||
}
|
||||
ARM_LIB_STACK m_data_2_start+m_data_2_size EMPTY -Stack_Size { ; Stack region growing down
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,86 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2019-2019 ARM Limited. All rights reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
* Licensed under the Apache License, Version 2.0 (the License); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* Setup a fixed single stack/heap memory model,
|
||||
* between the top of the RW/ZI region and the stackpointer
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
|
||||
#include <arm_compat.h>
|
||||
#endif
|
||||
|
||||
#include <rt_misc.h>
|
||||
#include <stdint.h>
|
||||
|
||||
extern char Image$$ARM_LIB_STACK$$ZI$$Limit[];
|
||||
extern char Image$$ARM_LIB_HEAP$$Base[];
|
||||
extern char Image$$ARM_LIB_HEAP$$ZI$$Limit[];
|
||||
extern __value_in_regs struct __initial_stackheap _mbed_user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3) {
|
||||
|
||||
struct __initial_stackheap r;
|
||||
r.heap_base = (uint32_t)Image$$ARM_LIB_HEAP$$Base;
|
||||
r.heap_limit = (uint32_t)Image$$ARM_LIB_HEAP$$ZI$$Limit;
|
||||
return r;
|
||||
}
|
||||
|
||||
#if !defined(MBED_CONF_RTOS_PRESENT) || !MBED_CONF_RTOS_PRESENT
|
||||
|
||||
/* The single region memory model would check stack collision at run time, verifying that
|
||||
* the heap pointer is underneath the stack pointer. With two-region memory model/RTOS-less or
|
||||
* multiple threads(stacks)/RTOS, the check gets meaningless and we must disable it. */
|
||||
#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
|
||||
__asm(".global __use_two_region_memory\n\t");
|
||||
__asm(".global __use_no_semihosting\n\t");
|
||||
#else
|
||||
#pragma import(__use_two_region_memory)
|
||||
#endif
|
||||
|
||||
/* Fix __user_setup_stackheap and ARM_LIB_STACK/ARM_LIB_HEAP cannot co-exist in RTOS-less build
|
||||
*
|
||||
* According AN241 (http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dai0241b/index.html),
|
||||
* __rt_entry has the following call sequence:
|
||||
* 1. _platform_pre_stackheap_init
|
||||
* 2. __user_setup_stackheap or setup the Stack Pointer (SP) by another method
|
||||
* 3. _platform_post_stackheap_init
|
||||
* 4. __rt_lib_init
|
||||
* 5. _platform_post_lib_init
|
||||
* 6. main()
|
||||
* 7. exit()
|
||||
*
|
||||
* Per our check, when __user_setup_stackheap and ARM_LIB_STACK/ARM_LIB_HEAP co-exist, neither
|
||||
* does __user_setup_stackheap get called and nor is ARM_LIB_HEAP used to get heap base/limit,
|
||||
* which are required to pass to __rt_lib_init later. To fix the issue, by subclass'ing
|
||||
* __rt_lib_init, heap base/limit are replaced with Image$$ARM_LIB_HEAP$$ZI$$Base/Limit if
|
||||
* ARM_LIB_HEAP region is defined in scatter file.
|
||||
*
|
||||
* The overriding __rt_lib_init is needed only for rtos-less code. For rtos code, __rt_entry is
|
||||
* overridden and the overriding __rt_lib_init here gets meaningless.
|
||||
*/
|
||||
extern __value_in_regs struct __argc_argv $Super$$__rt_lib_init(unsigned heapbase, unsigned heaptop);
|
||||
|
||||
__value_in_regs struct __argc_argv $Sub$$__rt_lib_init (unsigned heapbase, unsigned heaptop)
|
||||
{
|
||||
return $Super$$__rt_lib_init((unsigned) Image$$ARM_LIB_HEAP$$Base, (unsigned) Image$$ARM_LIB_HEAP$$ZI$$Limit);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -65,13 +65,8 @@ __ram_vector_table__ = 1;
|
|||
#define MBED_BOOT_STACK_SIZE 0x400
|
||||
#endif
|
||||
|
||||
/* With the RTOS in use, this does not affect the main stack size. The size of
|
||||
* the stack where main runs is determined via the RTOS. */
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
|
||||
__heap_size__ = 0x6000;
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x0400 : 0x0;
|
||||
M_CRASH_DATA_RAM_SIZE = 0x100;
|
||||
|
|
|
|||
|
|
@ -89,16 +89,6 @@
|
|||
|
||||
#ifndef INITIAL_SP
|
||||
#define INITIAL_SP (0x20030000UL)
|
||||
#if defined(__CC_ARM) || (defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050))
|
||||
extern uint32_t Image$$ARM_LIB_HEAP$$ZI$$Base[];
|
||||
extern uint32_t Image$$ARM_LIB_HEAP$$ZI$$Length[];
|
||||
extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Base[];
|
||||
extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Length[];
|
||||
#define HEAP_START ((unsigned char*) Image$$ARM_LIB_HEAP$$ZI$$Base)
|
||||
#define HEAP_SIZE ((uint32_t) Image$$ARM_LIB_HEAP$$ZI$$Length)
|
||||
#define ISR_STACK_START ((unsigned char*)Image$$ARM_LIB_STACK$$ZI$$Base)
|
||||
#define ISR_STACK_SIZE ((uint32_t)Image$$ARM_LIB_STACK$$ZI$$Length)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#elif defined(TARGET_SDT64B)
|
||||
|
|
@ -133,4 +123,11 @@ extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Length[];
|
|||
|
||||
#endif
|
||||
|
||||
#if defined(__ARMCC_VERSION)
|
||||
extern uint32_t Image$$ARM_LIB_HEAP$$ZI$$Base[];
|
||||
extern uint32_t Image$$ARM_LIB_HEAP$$ZI$$Length[];
|
||||
#define HEAP_START Image$$ARM_LIB_HEAP$$ZI$$Base
|
||||
#define HEAP_SIZE Image$$ARM_LIB_HEAP$$ZI$$Length
|
||||
#endif
|
||||
|
||||
#endif // MBED_MBED_RTX_H
|
||||
|
|
|
|||
|
|
@ -110,6 +110,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -45,15 +45,4 @@
|
|||
|
||||
#endif
|
||||
|
||||
#if (defined(__GNUC__) && !defined(__CC_ARM) && !defined(__ARMCC_VERSION) && defined(TWO_RAM_REGIONS))
|
||||
extern uint32_t __StackLimit[];
|
||||
extern uint32_t __StackTop[];
|
||||
extern uint32_t __end__[];
|
||||
extern uint32_t __HeapLimit[];
|
||||
#define HEAP_START ((unsigned char*)__end__)
|
||||
#define HEAP_SIZE ((uint32_t)((uint32_t)__HeapLimit - (uint32_t)HEAP_START))
|
||||
#define ISR_STACK_START ((unsigned char*)__StackLimit)
|
||||
#define ISR_STACK_SIZE ((uint32_t)((uint32_t)__StackTop - (uint32_t)__StackLimit))
|
||||
#endif
|
||||
|
||||
#endif /* MBED_MBED_RTX_H */
|
||||
|
|
|
|||
|
|
@ -166,6 +166,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -166,6 +166,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -160,6 +160,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -160,6 +160,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -160,6 +160,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -168,6 +168,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -160,6 +160,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -160,6 +160,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -238,6 +238,7 @@ SECTIONS
|
|||
/* Expand the heap to reach the stack boundary. */
|
||||
ASSERT(. <= (ORIGIN(RAM) + LENGTH(RAM) - MBED_BOOT_STACK_SIZE), "heap region overflowed into stack");
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - MBED_BOOT_STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
PROVIDE(__heap_start = ADDR(.heap));
|
||||
PROVIDE(__heap_size = SIZEOF(.heap));
|
||||
|
|
|
|||
|
|
@ -254,6 +254,7 @@ SECTIONS
|
|||
/* Expand the heap to reach the stack boundary. */
|
||||
ASSERT(. <= (ORIGIN(RAM) + LENGTH(RAM) - MBED_BOOT_STACK_SIZE), "heap region overflowed into stack");
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - MBED_BOOT_STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
PROVIDE(__heap_start = ADDR(.heap));
|
||||
PROVIDE(__heap_size = SIZEOF(.heap));
|
||||
|
|
|
|||
|
|
@ -1,42 +0,0 @@
|
|||
/******************************************************************************
|
||||
* @file startup_NUC472_442.c
|
||||
* @version V0.10
|
||||
* $Revision: 11 $
|
||||
* $Date: 15/09/02 10:02a $
|
||||
* @brief CMSIS Cortex-M4 Core Peripheral Access Layer Source File for NUC472/442 MCU
|
||||
*
|
||||
* @note
|
||||
* Copyright (C) 2013~2015 Nuvoton Technology Corp. All rights reserved.
|
||||
*****************************************************************************/
|
||||
|
||||
#include "M2351.h"
|
||||
#include <errno.h>
|
||||
#include "nu_miscutil.h"
|
||||
|
||||
extern uint32_t __mbed_sbrk_start;
|
||||
extern uint32_t __mbed_krbs_start;
|
||||
|
||||
#define NU_HEAP_ALIGN 4
|
||||
|
||||
/* Support heap with two-region model
|
||||
*
|
||||
* The default implementation of _sbrk() (in mbed_retarget.cpp) for GCC_ARM requires one-region
|
||||
* model (heap and stack share one region), which doesn't fit two-region model (heap and stack
|
||||
* are two distinct regions), e.g., stack in internal SRAM/heap in external SRAM on NUMAKER_PFM_NUC472.
|
||||
* Hence, override _sbrk() here to support heap with two-region model.
|
||||
*/
|
||||
void *_sbrk(int incr)
|
||||
{
|
||||
static uint32_t heap_ind = (uint32_t) &__mbed_sbrk_start;
|
||||
uint32_t heap_ind_old = NU_ALIGN_UP(heap_ind, NU_HEAP_ALIGN);
|
||||
uint32_t heap_ind_new = NU_ALIGN_UP(heap_ind_old + incr, NU_HEAP_ALIGN);
|
||||
|
||||
if (heap_ind_new > (uint32_t) &__mbed_krbs_start) {
|
||||
errno = ENOMEM;
|
||||
return (void *) -1;
|
||||
}
|
||||
|
||||
heap_ind = heap_ind_new;
|
||||
|
||||
return (void *) heap_ind_old;
|
||||
}
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
/******************************************************************************
|
||||
* @file startup_NUC472_442.c
|
||||
* @version V0.10
|
||||
* $Revision: 11 $
|
||||
* $Date: 15/09/02 10:02a $
|
||||
* @brief CMSIS Cortex-M4 Core Peripheral Access Layer Source File for NUC472/442 MCU
|
||||
*
|
||||
* @note
|
||||
* Copyright (C) 2013~2015 Nuvoton Technology Corp. All rights reserved.
|
||||
*****************************************************************************/
|
||||
|
||||
#include "M451Series.h"
|
||||
#include <errno.h>
|
||||
#include "nu_miscutil.h"
|
||||
|
||||
extern uint32_t __mbed_sbrk_start;
|
||||
extern uint32_t __mbed_krbs_start;
|
||||
|
||||
#define NU_HEAP_ALIGN 32
|
||||
|
||||
/* Support heap with two-region model
|
||||
*
|
||||
* The default implementation of _sbrk() (in mbed_retarget.cpp) for GCC_ARM requires one-region
|
||||
* model (heap and stack share one region), which doesn't fit two-region model (heap and stack
|
||||
* are two distinct regions), e.g., stack in internal SRAM/heap in external SRAM on NUMAKER_PFM_NUC472.
|
||||
* Hence, override _sbrk() here to support heap with two-region model.
|
||||
*/
|
||||
void *_sbrk(int incr)
|
||||
{
|
||||
static uint32_t heap_ind = (uint32_t) &__mbed_sbrk_start;
|
||||
uint32_t heap_ind_old = NU_ALIGN_UP(heap_ind, NU_HEAP_ALIGN);
|
||||
uint32_t heap_ind_new = NU_ALIGN_UP(heap_ind_old + incr, NU_HEAP_ALIGN);
|
||||
|
||||
if (heap_ind_new > (uint32_t) &__mbed_krbs_start) {
|
||||
errno = ENOMEM;
|
||||
return (void *) -1;
|
||||
}
|
||||
|
||||
heap_ind = heap_ind_new;
|
||||
|
||||
return (void *) heap_ind_old;
|
||||
}
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
/******************************************************************************
|
||||
* @file startup_NUC472_442.c
|
||||
* @version V0.10
|
||||
* $Revision: 11 $
|
||||
* $Date: 15/09/02 10:02a $
|
||||
* @brief CMSIS Cortex-M4 Core Peripheral Access Layer Source File for M480 MCU
|
||||
*
|
||||
* @note
|
||||
* Copyright (C) 2013~2015 Nuvoton Technology Corp. All rights reserved.
|
||||
*****************************************************************************/
|
||||
|
||||
#include "M480.h"
|
||||
#include <errno.h>
|
||||
#include "nu_miscutil.h"
|
||||
|
||||
extern uint32_t __mbed_sbrk_start;
|
||||
extern uint32_t __mbed_krbs_start;
|
||||
|
||||
#define NU_HEAP_ALIGN 32
|
||||
|
||||
/* Support heap with two-region model
|
||||
*
|
||||
* The default implementation of _sbrk() (in mbed_retarget.cpp) for GCC_ARM requires one-region
|
||||
* model (heap and stack share one region), which doesn't fit two-region model (heap and stack
|
||||
* are two distinct regions), e.g., stack in internal SRAM/heap in external SRAM on NUMAKER_PFM_NUC472.
|
||||
* Hence, override _sbrk() here to support heap with two-region model.
|
||||
*/
|
||||
void *_sbrk(int incr)
|
||||
{
|
||||
static uint32_t heap_ind = (uint32_t) &__mbed_sbrk_start;
|
||||
uint32_t heap_ind_old = NU_ALIGN_UP(heap_ind, NU_HEAP_ALIGN);
|
||||
uint32_t heap_ind_new = NU_ALIGN_UP(heap_ind_old + incr, NU_HEAP_ALIGN);
|
||||
|
||||
if (heap_ind_new > (uint32_t) &__mbed_krbs_start) {
|
||||
errno = ENOMEM;
|
||||
return (void *) -1;
|
||||
}
|
||||
|
||||
heap_ind = heap_ind_new;
|
||||
|
||||
return (void *) heap_ind_old;
|
||||
}
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
/******************************************************************************
|
||||
* @file startup_NUC472_442.c
|
||||
* @version V0.10
|
||||
* $Revision: 11 $
|
||||
* $Date: 15/09/02 10:02a $
|
||||
* @brief CMSIS Cortex-M4 Core Peripheral Access Layer Source File for NUC472/442 MCU
|
||||
*
|
||||
* @note
|
||||
* Copyright (C) 2013~2015 Nuvoton Technology Corp. All rights reserved.
|
||||
*****************************************************************************/
|
||||
|
||||
#include "Nano100Series.h"
|
||||
#include <errno.h>
|
||||
#include "nu_miscutil.h"
|
||||
|
||||
extern uint32_t __mbed_sbrk_start;
|
||||
extern uint32_t __mbed_krbs_start;
|
||||
|
||||
#define NU_HEAP_ALIGN 4
|
||||
|
||||
/* Support heap with two-region model
|
||||
*
|
||||
* The default implementation of _sbrk() (in mbed_retarget.cpp) for GCC_ARM requires one-region
|
||||
* model (heap and stack share one region), which doesn't fit two-region model (heap and stack
|
||||
* are two distinct regions), e.g., stack in internal SRAM/heap in external SRAM on NUMAKER_PFM_NUC472.
|
||||
* Hence, override _sbrk() here to support heap with two-region model.
|
||||
*/
|
||||
void *_sbrk(int incr)
|
||||
{
|
||||
static uint32_t heap_ind = (uint32_t) &__mbed_sbrk_start;
|
||||
uint32_t heap_ind_old = NU_ALIGN_UP(heap_ind, NU_HEAP_ALIGN);
|
||||
uint32_t heap_ind_new = NU_ALIGN_UP(heap_ind_old + incr, NU_HEAP_ALIGN);
|
||||
|
||||
if (heap_ind_new > (uint32_t) &__mbed_krbs_start) {
|
||||
errno = ENOMEM;
|
||||
return (void *) -1;
|
||||
}
|
||||
|
||||
heap_ind = heap_ind_new;
|
||||
|
||||
return (void *) heap_ind_old;
|
||||
}
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
/******************************************************************************
|
||||
* @file startup_NUC472_442.c
|
||||
* @version V0.10
|
||||
* $Revision: 11 $
|
||||
* $Date: 15/09/02 10:02a $
|
||||
* @brief CMSIS Cortex-M4 Core Peripheral Access Layer Source File for NUC472/442 MCU
|
||||
*
|
||||
* @note
|
||||
* Copyright (C) 2013~2015 Nuvoton Technology Corp. All rights reserved.
|
||||
*****************************************************************************/
|
||||
|
||||
#include "NUC472_442.h"
|
||||
#include <errno.h>
|
||||
#include "nu_miscutil.h"
|
||||
|
||||
extern uint32_t __mbed_sbrk_start;
|
||||
extern uint32_t __mbed_krbs_start;
|
||||
|
||||
#define NU_HEAP_ALIGN 32
|
||||
|
||||
/* Support heap with two-region model
|
||||
*
|
||||
* The default implementation of _sbrk() (in mbed_retarget.cpp) for GCC_ARM requires one-region
|
||||
* model (heap and stack share one region), which doesn't fit two-region model (heap and stack
|
||||
* are two distinct regions), e.g., stack in internal SRAM/heap in external SRAM on NUMAKER_PFM_NUC472.
|
||||
* Hence, override _sbrk() here to support heap with two-region model.
|
||||
*/
|
||||
void *_sbrk(int incr)
|
||||
{
|
||||
static uint32_t heap_ind = (uint32_t) &__mbed_sbrk_start;
|
||||
uint32_t heap_ind_old = NU_ALIGN_UP(heap_ind, NU_HEAP_ALIGN);
|
||||
uint32_t heap_ind_new = NU_ALIGN_UP(heap_ind_old + incr, NU_HEAP_ALIGN);
|
||||
|
||||
if (heap_ind_new > (uint32_t) &__mbed_krbs_start) {
|
||||
errno = ENOMEM;
|
||||
return (void *) -1;
|
||||
}
|
||||
|
||||
heap_ind = heap_ind_new;
|
||||
|
||||
return (void *) heap_ind_old;
|
||||
}
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
/* mbed Microcontroller Library - stackheap
|
||||
* Copyright (C) 2009-2011 ARM Limited. All rights reserved.
|
||||
*
|
||||
* Setup a fixed single stack/heap memory model,
|
||||
* between the top of the RW/ZI region and the stackpointer
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
|
||||
#include <arm_compat.h>
|
||||
#endif
|
||||
|
||||
#include <rt_misc.h>
|
||||
#include <stdint.h>
|
||||
|
||||
extern char Image$$ARM_LIB_STACK$$ZI$$Limit[];
|
||||
extern char Image$$ARM_LIB_HEAP$$Base[];
|
||||
extern char Image$$ARM_LIB_HEAP$$ZI$$Limit[];
|
||||
extern __value_in_regs struct __initial_stackheap _mbed_user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3) {
|
||||
|
||||
struct __initial_stackheap r;
|
||||
r.heap_base = (uint32_t)Image$$ARM_LIB_HEAP$$Base;
|
||||
r.heap_limit = (uint32_t)Image$$ARM_LIB_HEAP$$ZI$$Limit;
|
||||
return r;
|
||||
}
|
||||
|
||||
#if !defined(MBED_CONF_RTOS_PRESENT) || !MBED_CONF_RTOS_PRESENT
|
||||
|
||||
/* The single region memory model would check stack collision at run time, verifying that
|
||||
* the heap pointer is underneath the stack pointer. With two-region memory model/RTOS-less or
|
||||
* multiple threads(stacks)/RTOS, the check gets meaningless and we must disable it. */
|
||||
#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
|
||||
__asm(".global __use_two_region_memory\n\t");
|
||||
__asm(".global __use_no_semihosting\n\t");
|
||||
#else
|
||||
#pragma import(__use_two_region_memory)
|
||||
#endif
|
||||
|
||||
/* Fix __user_setup_stackheap and ARM_LIB_STACK/ARM_LIB_HEAP cannot co-exist in RTOS-less build
|
||||
*
|
||||
* According AN241 (http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dai0241b/index.html),
|
||||
* __rt_entry has the following call sequence:
|
||||
* 1. _platform_pre_stackheap_init
|
||||
* 2. __user_setup_stackheap or setup the Stack Pointer (SP) by another method
|
||||
* 3. _platform_post_stackheap_init
|
||||
* 4. __rt_lib_init
|
||||
* 5. _platform_post_lib_init
|
||||
* 6. main()
|
||||
* 7. exit()
|
||||
*
|
||||
* Per our check, when __user_setup_stackheap and ARM_LIB_STACK/ARM_LIB_HEAP co-exist, neither
|
||||
* does __user_setup_stackheap get called and nor is ARM_LIB_HEAP used to get heap base/limit,
|
||||
* which are required to pass to __rt_lib_init later. To fix the issue, by subclass'ing
|
||||
* __rt_lib_init, heap base/limit are replaced with Image$$ARM_LIB_HEAP$$ZI$$Base/Limit if
|
||||
* ARM_LIB_HEAP region is defined in scatter file.
|
||||
*
|
||||
* The overriding __rt_lib_init is needed only for rtos-less code. For rtos code, __rt_entry is
|
||||
* overridden and the overriding __rt_lib_init here gets meaningless.
|
||||
*/
|
||||
extern __value_in_regs struct __argc_argv $Super$$__rt_lib_init(unsigned heapbase, unsigned heaptop);
|
||||
|
||||
__value_in_regs struct __argc_argv $Sub$$__rt_lib_init (unsigned heapbase, unsigned heaptop)
|
||||
{
|
||||
return $Super$$__rt_lib_init((unsigned) Image$$ARM_LIB_HEAP$$Base, (unsigned) Image$$ARM_LIB_HEAP$$ZI$$Limit);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -21,24 +21,13 @@
|
|||
|
||||
#if defined(TARGET_NUVOTON)
|
||||
|
||||
#if defined(__CC_ARM) || (defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050))
|
||||
#if defined(__ARMCC_VERSION)
|
||||
extern uint32_t Image$$ARM_LIB_HEAP$$ZI$$Base[];
|
||||
extern uint32_t Image$$ARM_LIB_HEAP$$ZI$$Length[];
|
||||
extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Base[];
|
||||
extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Length[];
|
||||
#define HEAP_START ((unsigned char*) Image$$ARM_LIB_HEAP$$ZI$$Base)
|
||||
#define HEAP_SIZE ((uint32_t) Image$$ARM_LIB_HEAP$$ZI$$Length)
|
||||
#define ISR_STACK_START ((unsigned char*)Image$$ARM_LIB_STACK$$ZI$$Base)
|
||||
#define ISR_STACK_SIZE ((uint32_t)Image$$ARM_LIB_STACK$$ZI$$Length)
|
||||
#define HEAP_START Image$$ARM_LIB_HEAP$$ZI$$Base
|
||||
#define HEAP_SIZE Image$$ARM_LIB_HEAP$$ZI$$Length
|
||||
#elif defined(__GNUC__)
|
||||
extern uint32_t __StackTop;
|
||||
extern uint32_t __StackLimit;
|
||||
extern uint32_t __end__;
|
||||
extern uint32_t __HeapLimit;
|
||||
#define HEAP_START ((unsigned char*) &__end__)
|
||||
#define HEAP_SIZE ((uint32_t) ((uint32_t) &__HeapLimit - (uint32_t) HEAP_START))
|
||||
#define ISR_STACK_START ((unsigned char*) &__StackLimit)
|
||||
#define ISR_STACK_SIZE ((uint32_t)((uint32_t) &__StackTop - (uint32_t) &__StackLimit))
|
||||
/* No region declarations needed */
|
||||
#elif defined(__ICCARM__)
|
||||
/* No region declarations needed */
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -138,6 +138,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -138,6 +138,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -136,6 +136,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -136,6 +136,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -136,6 +136,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -136,6 +136,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -137,6 +137,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -136,6 +136,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -136,6 +136,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -138,6 +138,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -133,6 +133,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -133,6 +133,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -133,6 +133,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -150,6 +150,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -137,6 +137,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -137,6 +137,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -139,6 +139,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM1) + LENGTH(RAM1) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM1
|
||||
|
||||
|
|
|
|||
|
|
@ -133,6 +133,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -133,6 +133,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -133,6 +133,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -133,6 +133,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -134,6 +134,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
end = __end__;
|
||||
*(.heap*)
|
||||
. = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
} > RAM
|
||||
|
||||
|
|
|
|||
|
|
@ -85,9 +85,6 @@ __ram_vector_table__ = 1;
|
|||
#endif
|
||||
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
__heap_size__ = 0x4000;
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0800;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0xE4 : 0x0;
|
||||
RPMSG_SHMEM_SIZE = DEFINED(__use_shmem__) ? 0x1800 : 0;
|
||||
|
|
@ -273,7 +270,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data) + LENGTH(m_data) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data
|
||||
|
|
|
|||
|
|
@ -53,9 +53,6 @@ __ram_vector_table__ = 1;
|
|||
#endif
|
||||
|
||||
__stack_size__ = MBED_BOOT_STACK_SIZE;
|
||||
__heap_size__ = 0xC000;
|
||||
|
||||
HEAP_SIZE = DEFINED(__heap_size__) ? __heap_size__ : 0x0400;
|
||||
STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0800;
|
||||
M_VECTOR_RAM_SIZE = DEFINED(__ram_vector_table__) ? 0x400 : 0x0;
|
||||
|
||||
|
|
@ -223,7 +220,7 @@ SECTIONS
|
|||
__end__ = .;
|
||||
PROVIDE(end = .);
|
||||
__HeapBase = .;
|
||||
. += HEAP_SIZE;
|
||||
. = ORIGIN(m_data) + LENGTH(m_data) - STACK_SIZE;
|
||||
__HeapLimit = .;
|
||||
__heap_limit = .; /* Add for _sbrk */
|
||||
} > m_data
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue