510890b207
.. and enable it on atmel-samd and raspberrypi. On trinket_m0 this saves 96 net bytes of flash. There are 216 bytes actually saved by reducing the flash storage size of the property descriptors, but added code in several paths takes back over half of the 'raw savings'. By organizing the "get-only" and "get-set" (but no delete) properties each in a different section, we can represent then more efficiently. Testing performed: that a get-only property can still be gotten but can't be set or deleted; that a get-set property can sill be gotten or set but can't be deleted. Tested on pygamer. Because this requires linker file support, I only enabled it on two of the ports.
294 lines
7.6 KiB
Plaintext
294 lines
7.6 KiB
Plaintext
/* Based on GCC ARM embedded samples.
|
|
Defines the following symbols for use by code:
|
|
__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 (== StackTop)
|
|
*/
|
|
|
|
MEMORY
|
|
{
|
|
FLASH_FIRMWARE (rx) : ORIGIN = 0x10000000, LENGTH = 1020k
|
|
RAM (rwx) : ORIGIN = 0x20000000, LENGTH = 256k
|
|
SCRATCH_X (rwx) : ORIGIN = 0x20040000, LENGTH = 4k
|
|
SCRATCH_Y (rwx) : ORIGIN = 0x20041000, LENGTH = 4k
|
|
}
|
|
|
|
ENTRY(_entry_point)
|
|
|
|
SECTIONS
|
|
{
|
|
/* Second stage bootloader is prepended to the image. It must be 256 bytes big
|
|
and checksummed. It is usually built by the boot_stage2 target
|
|
in the Pico SDK
|
|
*/
|
|
|
|
.flash_begin : {
|
|
__flash_binary_start = .;
|
|
} > FLASH_FIRMWARE
|
|
|
|
.boot2 : {
|
|
__boot2_start__ = .;
|
|
KEEP (*(.boot2))
|
|
__boot2_end__ = .;
|
|
} > FLASH_FIRMWARE
|
|
|
|
ASSERT(__boot2_end__ - __boot2_start__ == 256,
|
|
"ERROR: Pico second stage bootloader must be 256 bytes in size")
|
|
|
|
/* The second stage will always enter the image at the start of .text.
|
|
The debugger will use the ELF entry point, which is the _entry_point
|
|
symbol if present, otherwise defaults to start of .text.
|
|
This can be used to transfer control back to the bootrom on debugger
|
|
launches only, to perform proper flash setup.
|
|
*/
|
|
|
|
.text : {
|
|
__logical_binary_start = .;
|
|
KEEP (*(.vectors))
|
|
KEEP (*(.binary_info_header))
|
|
__binary_info_header_end = .;
|
|
KEEP (*(.reset))
|
|
/* TODO revisit this now memset/memcpy/float in ROM */
|
|
/* bit of a hack right now to exclude all floating point and time critical (e.g. memset, memcpy) code from
|
|
* FLASH ... we will include any thing excluded here in .data below by default */
|
|
*(.init)
|
|
|
|
__property_getter_start = .;
|
|
*(.property_getter)
|
|
__property_getter_end = .;
|
|
__property_getset_start = .;
|
|
*(.property_getset)
|
|
__property_getset_end = .;
|
|
|
|
*(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .text*)
|
|
*(.fini)
|
|
/* Pull all c'tors into .text */
|
|
*crtbegin.o(.ctors)
|
|
*crtbegin?.o(.ctors)
|
|
*(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
|
|
*(SORT(.ctors.*))
|
|
*(.ctors)
|
|
/* Followed by destructors */
|
|
*crtbegin.o(.dtors)
|
|
*crtbegin?.o(.dtors)
|
|
*(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
|
|
*(SORT(.dtors.*))
|
|
*(.dtors)
|
|
|
|
*(.eh_frame*)
|
|
. = ALIGN(4);
|
|
} > FLASH_FIRMWARE
|
|
|
|
.rodata : {
|
|
*(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .rodata*)
|
|
. = ALIGN(4);
|
|
*(SORT_BY_ALIGNMENT(SORT_BY_NAME(.flashdata*)))
|
|
. = ALIGN(4);
|
|
} > FLASH_FIRMWARE
|
|
|
|
.ARM.extab :
|
|
{
|
|
*(.ARM.extab* .gnu.linkonce.armextab.*)
|
|
} > FLASH_FIRMWARE
|
|
|
|
__exidx_start = .;
|
|
.ARM.exidx :
|
|
{
|
|
*(.ARM.exidx* .gnu.linkonce.armexidx.*)
|
|
} > FLASH_FIRMWARE
|
|
__exidx_end = .;
|
|
|
|
/* Machine inspectable binary information */
|
|
. = ALIGN(4);
|
|
__binary_info_start = .;
|
|
.binary_info :
|
|
{
|
|
KEEP(*(.binary_info.keep.*))
|
|
*(.binary_info.*)
|
|
} > FLASH_FIRMWARE
|
|
__binary_info_end = .;
|
|
. = ALIGN(4);
|
|
|
|
/* End of .text-like segments */
|
|
__etext = .;
|
|
|
|
.ram_vector_table (COPY): {
|
|
*(.ram_vector_table)
|
|
} > RAM
|
|
|
|
.data : {
|
|
__data_start__ = .;
|
|
*(vtable)
|
|
|
|
*(.time_critical*)
|
|
|
|
/* remaining .text and .rodata; i.e. stuff we exclude above because we want it in RAM */
|
|
*(.text*)
|
|
. = ALIGN(4);
|
|
*(.rodata*)
|
|
. = ALIGN(4);
|
|
|
|
*(.data*)
|
|
|
|
. = ALIGN(4);
|
|
*(.after_data.*)
|
|
. = ALIGN(4);
|
|
/* preinit data */
|
|
PROVIDE_HIDDEN (__mutex_array_start = .);
|
|
KEEP(*(SORT(.mutex_array.*)))
|
|
KEEP(*(.mutex_array))
|
|
PROVIDE_HIDDEN (__mutex_array_end = .);
|
|
|
|
. = ALIGN(4);
|
|
/* preinit data */
|
|
PROVIDE_HIDDEN (__preinit_array_start = .);
|
|
KEEP(*(SORT(.preinit_array.*)))
|
|
KEEP(*(.preinit_array))
|
|
PROVIDE_HIDDEN (__preinit_array_end = .);
|
|
|
|
. = ALIGN(4);
|
|
/* init data */
|
|
PROVIDE_HIDDEN (__init_array_start = .);
|
|
KEEP(*(SORT(.init_array.*)))
|
|
KEEP(*(.init_array))
|
|
PROVIDE_HIDDEN (__init_array_end = .);
|
|
|
|
. = ALIGN(4);
|
|
/* finit data */
|
|
PROVIDE_HIDDEN (__fini_array_start = .);
|
|
*(SORT(.fini_array.*))
|
|
*(.fini_array)
|
|
PROVIDE_HIDDEN (__fini_array_end = .);
|
|
|
|
*(.jcr)
|
|
. = ALIGN(4);
|
|
/* All data end */
|
|
__data_end__ = .;
|
|
} > RAM AT> FLASH_FIRMWARE
|
|
|
|
.itcm :
|
|
{
|
|
. = ALIGN(4);
|
|
*(.itcm.*)
|
|
|
|
. = ALIGN(4);
|
|
} > RAM AT> FLASH_FIRMWARE
|
|
_ld_itcm_destination = ADDR(.itcm);
|
|
_ld_itcm_flash_copy = LOADADDR(.itcm);
|
|
_ld_itcm_size = SIZEOF(.itcm);
|
|
|
|
.dtcm_data :
|
|
{
|
|
. = ALIGN(4);
|
|
|
|
*(.dtcm_data.*)
|
|
|
|
. = ALIGN(4);
|
|
} > RAM AT> FLASH_FIRMWARE
|
|
_ld_dtcm_data_destination = ADDR(.dtcm_data);
|
|
_ld_dtcm_data_flash_copy = LOADADDR(.dtcm_data);
|
|
_ld_dtcm_data_size = SIZEOF(.dtcm_data);
|
|
|
|
.dtcm_bss :
|
|
{
|
|
. = ALIGN(4);
|
|
|
|
*(.dtcm_bss.*)
|
|
|
|
. = ALIGN(4);
|
|
} > RAM AT> RAM
|
|
_ld_dtcm_bss_start = ADDR(.dtcm_bss);
|
|
_ld_dtcm_bss_size = SIZEOF(.dtcm_bss);
|
|
|
|
.uninitialized_data (COPY): {
|
|
. = ALIGN(4);
|
|
*(.uninitialized_data*)
|
|
} > RAM
|
|
|
|
/* Start and end symbols must be word-aligned */
|
|
.scratch_x : {
|
|
__scratch_x_start__ = .;
|
|
*(.scratch_x.*)
|
|
. = ALIGN(4);
|
|
__scratch_x_end__ = .;
|
|
} > SCRATCH_X AT > FLASH_FIRMWARE
|
|
__scratch_x_source__ = LOADADDR(.scratch_x);
|
|
|
|
.scratch_y : {
|
|
__scratch_y_start__ = .;
|
|
*(.scratch_y.*)
|
|
. = ALIGN(4);
|
|
__scratch_y_end__ = .;
|
|
} > SCRATCH_Y AT > FLASH_FIRMWARE
|
|
__scratch_y_source__ = LOADADDR(.scratch_y);
|
|
|
|
.bss : {
|
|
. = ALIGN(4);
|
|
__bss_start__ = .;
|
|
*(SORT_BY_ALIGNMENT(SORT_BY_NAME(.bss*)))
|
|
*(COMMON)
|
|
. = ALIGN(4);
|
|
__bss_end__ = .;
|
|
} > RAM
|
|
|
|
.heap (COPY):
|
|
{
|
|
__end__ = .;
|
|
end = __end__;
|
|
*(.heap*)
|
|
__HeapLimit = .;
|
|
} > RAM
|
|
|
|
/* .stack*_dummy section doesn't contains any symbols. It is only
|
|
* used for linker to calculate size of stack sections, and assign
|
|
* values to stack symbols later
|
|
*
|
|
* stack1 section may be empty/missing if platform_launch_core1 is not used */
|
|
|
|
/* by default we put core 0 stack at the end of scratch Y, so that if core 1
|
|
* stack is not used then all of SCRATCH_X is free.
|
|
*/
|
|
.stack1_dummy (COPY):
|
|
{
|
|
*(.stack1*)
|
|
} > SCRATCH_X
|
|
.stack_dummy (COPY):
|
|
{
|
|
*(.stack*)
|
|
} > SCRATCH_Y
|
|
|
|
.flash_end : {
|
|
__flash_binary_end = .;
|
|
} > FLASH_FIRMWARE
|
|
|
|
/* stack limit is poorly named, but historically is maximum heap ptr */
|
|
__StackLimit = ORIGIN(RAM) + LENGTH(RAM);
|
|
__StackOneTop = ORIGIN(SCRATCH_X) + LENGTH(SCRATCH_X);
|
|
__StackTop = ORIGIN(SCRATCH_Y) + LENGTH(SCRATCH_Y);
|
|
__StackOneBottom = __StackOneTop - SIZEOF(.stack1_dummy);
|
|
__StackBottom = __StackTop - SIZEOF(.stack_dummy);
|
|
PROVIDE(__stack = __StackTop);
|
|
|
|
/* Check if data + heap + stack exceeds RAM limit */
|
|
ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed")
|
|
|
|
ASSERT( __binary_info_header_end - __logical_binary_start <= 256, "Binary info must be in first 256 bytes of the binary")
|
|
/* todo assert on extra code */
|
|
}
|