/**************************************************************************** * * Copyright 2020 Samsung Electronics 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. * ****************************************************************************/ /* * This file is derivative of CMSIS V5.00 gcc_arm.ld */ /* Linker script to configure memory regions. */ #if !defined(MBED_APP_START) #define MBED_APP_START 0x406F4000 #endif #if !defined(MBED_APP_SIZE) #define MBED_APP_SIZE 1492K #endif #if !defined(MBED_RAM_START) #define MBED_RAM_START 0x00100000 #endif #if !defined(MBED_RAM_SIZE) #define MBED_RAM_SIZE 320K #endif MEMORY { FLASH (rx) : ORIGIN = MBED_APP_START, LENGTH = MBED_APP_SIZE RAM (rwx) : ORIGIN = MBED_RAM_START, LENGTH = MBED_RAM_SIZE VECTORS (rwx) : ORIGIN = 0x00000000, LENGTH = 8K } /* Linker script to place sections and symbol values. Should be used together * with other linker script that defines memory regions FLASH and RAM. * It references following symbols, which must be defined in code: * Reset_Handler : Entry of reset handler * * It defines following symbols, which code can use without definition: * __exidx_start * __exidx_end * __etext * __data_start__ * __preinit_array_start * __preinit_array_end * __init_array_start * __init_array_end * __fini_array_start * __fini_array_end * __data_end__ * __bss_start__ * __bss_end__ * __end__ * end * __HeapLimit * __StackLimit * __StackTop * __stack */ ENTRY(Reset_Handler) /* Heap 1/4 of ram and stack 1/8 */ __stack_size__ = 0x0400; STACK_SIZE = DEFINED(__stack_size__) ? __stack_size__ : 0x0400; /* Size of the vector table in SRAM */ M_VECTOR_RAM_SIZE = 0x140; SECTIONS { /* Note: The uVisor expects this section at a fixed location, as specified by the porting process configuration parameter: FLASH_OFFSET. */ __UVISOR_TEXT_OFFSET = 0x0; __UVISOR_TEXT_START = ORIGIN(FLASH) + __UVISOR_TEXT_OFFSET; .text __UVISOR_TEXT_START : { __vector_table = .; KEEP(*(.vector_table)) __vector_table_end = .; . = ALIGN(4); *(.text*) KEEP(*(.init)) KEEP(*(.fini)) /* .ctors */ *crtbegin.o(.ctors) *crtbegin?.o(.ctors) *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors) *(SORT(.ctors.*)) *(.ctors) /* .dtors */ *crtbegin.o(.dtors) *crtbegin?.o(.dtors) *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors) *(SORT(.dtors.*)) *(.dtors) *(.rodata*) KEEP(*(.eh_frame*)) } > FLASH .isr_vector : { . = ALIGN(4); _v_start = ABSOLUTE(.); *(.vector_table) _v_end = ABSOLUTE(.); } > VECTORS AT > FLASH .ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } > FLASH __exidx_start = .; .ARM.exidx : { *(.ARM.exidx* .gnu.linkonce.armexidx.*) } > FLASH __exidx_end = .; .cordio : { *CORDIO_RO_2.1.o *TRIM_2.1.o } > FLASH .interrupts_ram : { . = ALIGN(4); __VECTOR_RAM__ = .; __interrupts_ram_start__ = .; /* Create a global symbol at data start */ . += M_VECTOR_RAM_SIZE; . = ALIGN(4); __interrupts_ram_end__ = .; /* Define a global symbol at data end */ } > RAM /* ensure that uvisor bss is at the beginning of memory */ /* Note: The uVisor expects this section at a fixed location, as specified by * the porting process configuration parameter: SRAM_OFFSET. */ __UVISOR_SRAM_OFFSET = 0x140; __UVISOR_BSS_START = ORIGIN(RAM) + __UVISOR_SRAM_OFFSET; .data : { PROVIDE(__etext = LOADADDR(.data)); . = ALIGN(4); __data_start__ = .; *(vtable) *(.data) *(.data*) . = ALIGN(4); /* preinit data */ PROVIDE (__preinit_array_start = .); KEEP(*(.preinit_array)) PROVIDE (__preinit_array_end = .); . = ALIGN(4); /* init data */ PROVIDE (__init_array_start = .); KEEP(*(SORT(.init_array.*))) KEEP(*(.init_array)) PROVIDE (__init_array_end = .); . = ALIGN(4); /* finit data */ PROVIDE (__fini_array_start = .); KEEP(*(SORT(.fini_array.*))) KEEP(*(.fini_array)) PROVIDE (__fini_array_end = .); . = ALIGN(4); /* All data end */ __data_end__ = .; } > RAM AT > FLASH .ramfunc ALIGN(4): { _sramfuncs = ABSOLUTE(.); KEEP(*(.ramfunc .ramfunc.*)) _eramfuncs = ABSOLUTE(.); } > RAM AT > FLASH _framfuncs = LOADADDR(.ramfunc); /* From now on you can insert any other SRAM region. */ .uninitialized (NOLOAD): { . = ALIGN(32); __uninitialized_start = .; *(.uninitialized) KEEP(*(.keep.uninitialized)) . = ALIGN(32); __uninitialized_end = .; } > RAM .bss : { . = ALIGN(4); __START_BSS = .; __bss_start__ = .; *(.bss) *(.bss*) *(COMMON) . = ALIGN(4); __bss_end__ = .; __END_BSS = .; } > RAM bss_size = __bss_end__ - __bss_start__; .heap : { . = ALIGN(8); __end__ = .; PROVIDE(end = .); __HeapBase = .; . = ORIGIN(RAM) + LENGTH(RAM) - STACK_SIZE - 0x1000; __HeapLimit = .; __heap_limit = .; /* Add for _sbrk */ } > RAM /* Set stack top to end of RAM, and stack limit move down by * size of stack_dummy section */ __StackTop = ORIGIN(RAM) + LENGTH(RAM); __StackLimit = __StackTop - STACK_SIZE; PROVIDE(__stack = __StackTop); /* Check if data + heap + stack exceeds RAM limit */ ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed with stack") } /* End of sections */