newlib/libgloss/msp430/msp430xl-sim.ld

455 lines
14 KiB
Plaintext

/* Copyright (c) 2013-2015 Red Hat, Inc. All rights reserved.
This copyrighted material is made available to anyone wishing to use,
modify, copy, or redistribute it subject to the terms and conditions of
the BSD License. This program is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY expressed or implied, including the
implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
A copy of this license is available at http://www.opensource.org/licenses.
Any Red Hat trademarks that are incorporated in the source code or
documentation are not subject to the BSD License and may only be used or
replicated with the express permission of Red Hat, Inc. */
/* Example linker script, for large MSP430X executables. */
OUTPUT_ARCH(msp430)
ENTRY(_start)
INCLUDE intr_vectors.ld
/* Note - These memory regions are just examples. Real MSP430 MCUs will have
different varieties and sizes of RAM, ROM and FLASH. Not all devices will
have all of these regions either. Device specific linker scripts are
provided by TI, so this file is intended to be used as a guide and so that
toolchain tests can be run against the simulator. */
MEMORY
{
RAM (rw) : ORIGIN = 0x00500, LENGTH = 0x01b00
ROM (rx) : ORIGIN = 0x02000, LENGTH = 0x0df00
/* The regions from intr_vectors.ld go here. */
HIFRAM (rw) : ORIGIN = 0x10000, LENGTH = 0x80000
HIROM (rx) : ORIGIN = 0x90000, LENGTH = 0x70000
}
SECTIONS
{
.resetvec :
{
*(.resetvec)
} > VECT31
.rodata :
{
. = ALIGN(2);
*(.plt)
. = ALIGN(2);
*(.lower.rodata.* .lower.rodata)
/* Note: By default we do not have this line:
*(.either.rodata.*) *(.either.rodata)
defined here, or anywhere else in this script. This is deliberate.
The algorithm in the linker that automatically places rodata into
either the .rodata or the .upper.rodata sections relies upon the
fact that the .either.rodata section is not defined, and that the
.upper.rodata section is defined. If the .upper.rodata is not
defined in this script then the line above should be restored so that
code compiled with -mdata-region=either enabled will still work.
The same reasoning applies to the absence of definitions for the
.either.text, .either.data and .either.bss sections as well. */
. = ALIGN(2);
*(.rodata .rodata.* .gnu.linkonce.r.* .const .const:*)
*(.rodata1)
. = ALIGN(2);
KEEP (*(.gcc_except_table)) *(.gcc_except_table.*)
PROVIDE (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE (__preinit_array_end = .);
PROVIDE (__init_array_start = .);
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array))
PROVIDE (__init_array_end = .);
PROVIDE (__fini_array_start = .);
KEEP (*(.fini_array))
KEEP (*(SORT(.fini_array.*)))
PROVIDE (__fini_array_end = .);
} > ROM
/* Note: This is a separate .rodata section for sections which are
read only but which older linkers treat as read-write.
This prevents older linkers from marking the entire .rodata
section as read-write. */
.rodata2 : {
. = ALIGN(2);
*(.eh_frame_hdr)
KEEP (*(.eh_frame))
/* gcc uses crtbegin.o to find the start of the constructors, so
we make sure it is first. Because this is a wildcard, it
doesn't matter if the user does not actually link against
crtbegin.o; the linker won't look for a file to match a
wildcard. The wildcard also means that it doesn't matter which
directory crtbegin.o is in. */
KEEP (*crtbegin*.o(.ctors))
/* We don't want to include the .ctor section from from the
crtend.o file until after the sorted ctors. The .ctor section
from the crtend file contains the end of ctors marker and it
must be last */
KEEP (*(EXCLUDE_FILE (*crtend*.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
KEEP (*crtbegin*.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend*.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
} > ROM
.upper.rodata :
{
/* Note: If this section is not defined then please add:
*(.either.rodata.*) *(.either.rodata)
to the definition of the .rodata section above. This
will allow code compiled with -mdata-region=either to
work properly. */
. = ALIGN(2);
*(.upper.rodata.* .upper.rodata)
} > HIROM
.data :
{
. = ALIGN(2);
PROVIDE (__datastart = .);
*(.lower.data.* .lower.data)
. = ALIGN(2);
KEEP (*(.jcr))
*(.data.rel.ro.local) *(.data.rel.ro*)
*(.dynamic)
. = ALIGN(2);
*(.data .data.* .gnu.linkonce.d.*)
/* See the note in .rodata section about why we do not have this line here:
*(.either.data.* .either.data)
*/
KEEP (*(.gnu.linkonce.d.*personality*))
SORT(CONSTRUCTORS)
*(.data1)
*(.got.plt) *(.got)
/* We want the small data sections together, so single-instruction offsets
can access them all, and initialized data all before uninitialized, so
we can shorten the on-disk segment size. */
. = ALIGN(2);
*(.sdata .sdata.* .gnu.linkonce.s.* D_2 D_1)
. = ALIGN(2);
_edata = .;
PROVIDE (edata = .);
PROVIDE (__dataend = .);
/* See the comment in the .upper.data section about the need
to copy data from ROM into RAM at program start up. */
} > RAM AT> ROM
/* Note that crt0 assumes that __romdatacopysize is a multiple of two.
All the start/stop symbols are also assumed to be word-aligned. */
__romdatastart = LOADADDR(.data);
__romdatacopysize = SIZEOF(.data);
/* ------------------- start of .upper.data sections.---------------- */
/* Note: If both HIROM and HIFRAM are available then the .upper.data
section should look like this:
. = ALIGN(2);
.upper.data :
{
__upper_data_init = LOADADDR (.upper.data);
/* Status word. * /
SHORT(1);
__high_datastart = .;
*(.upper.data.* .upper.data)
__high_dataend = .;
} > HIFRAM AT> HIROM
__rom_highdatacopysize = SIZEOF(.upper.data) - 2;
__rom_highdatastart = LOADADDR(.upper.data) + 2;
If only HIFRAM is available then the layout below must look like this:
.upper.data :
{
. = ALIGN(2);
__high_datastart = .;
*(.upper.data.* .upper.data)
__high_dataend = .;
} > HIFRAM
__rom_highdatacopysize = SIZEOF(.upper.data);
.shadow.upper.data :
{
. = ALIGN(2);
__upper_data_init = .;
/* Status word. * /
SHORT(0);
/* Space for the copy of .upper.data. * /
. = . + SIZEOF(.upper.data) - 2;
} > HIFRAM
__rom_highdatastart = LOADADDR(.shadow.upper.data) + 2;
Note - remove the space in this sequence: * / (twice) when you copy one
of the script fragments above into your script.
Note - the symbols defined here are *not* enclosed by the PROVIDE
keyword. This is deliberate. The crt0 library provides weak
definitions of these symbols and those weak definitions *must* be
overriden by the correct values.
The status word is used to control how the .upper.data section
is initialized at application start up. If the word is non-zero
then data is copied from __rom_highdatastart to __high_datastart.
This corresponds with copying the contents of .upper.data from its
load address (HIROM) to its run-time address (HIFRAM) in the first
scenario, or from the .shadow.upper.section to the .upper.data in
the second scenario.
If the status word is zero then the data is copied the other way
and the word is set to one. This only happens when the second
scenario is in play, and only the very first time the application
starts running. This makes sure that the .shadow.upper.data section
contains a pristine copy of the .upper.data section that can be used
to reinitialize the .upper.data section upon device reset.
The status word is necessary as this allows us to have one routine
in crt0 that can handle either form of .upper.data layout. IE crt0
is linker script agnostic.
Note - if the .upper.data section is not going to be defined at all
then please add this line back into the .data section above:
*(.either.data.* .either.data)
*/
. = ALIGN(2);
.upper.data :
{
__upper_data_init = LOADADDR (.upper.data);
/* Status word. */
SHORT(1);
__high_datastart = .;
*(.upper.data.* .upper.data)
__high_dataend = .;
} > HIFRAM AT> HIROM
__rom_highdatacopysize = SIZEOF(.upper.data) - 2;
__rom_highdatastart = LOADADDR(.upper.data) + 2;
/* ------------------- end of .upper.data sections.---------------- */
.bss :
{
. = ALIGN(2);
PROVIDE (__bssstart = .);
*(.lower.bss.* .lower.bss)
*(.dynbss)
*(.sbss .sbss.*)
*(.bss .bss.* .gnu.linkonce.b.*)
/* See the note in .rodata section about why we do not have this line here:
*(.either.bss.* .either.bss)
*/
. = ALIGN(2);
*(COMMON)
. = ALIGN(2);
PROVIDE (__bssend = .);
} > RAM
PROVIDE (__bsssize = SIZEOF(.bss));
/* This section contains data that is not initialised during load
*or* application reset. */
.noinit (NOLOAD) :
{
. = ALIGN(2);
PROVIDE (__noinit_start = .);
*(.noinit)
. = ALIGN(2);
PROVIDE (__noinit_end = .);
} > RAM
/* This section contains data that *is* initialised during load
but *not* on application reset. This section should be in FLASH. */
.persistent :
{
. = ALIGN(2);
PROVIDE (__persistent_start = .);
*(.persistent)
. = ALIGN(2);
PROVIDE (__persistent_end = .);
} > HIFRAM
.upper.bss :
{
/* Note - if this section is not going to be defined then please
add this line back into the definition of the .bss section above:
*(.either.bss.* .either.bss)
*/
. = ALIGN(2);
__high_bssstart = .;
*(.upper.bss.* .upper.bss)
. = ALIGN(2);
__high_bssend = .;
} > HIFRAM
__high_bsssize = SIZEOF(.upper.bss);
/* We create this section so that "end" will always be in the
HIFRAM region (matching .stack below), even if the .upper.bss
section is empty. */
.heap_start :
{
. = ALIGN(2);
_end = .;
PROVIDE (end = .);
LONG(0);
} > HIFRAM
/* The __stack_size value of 0x100 is just a guess, but since it is
PROVIDEd the user can override it on the command line. It has to be
set here, rather than inside the .stack section, as symbols defined
inside sections are only evaluated during the final phase of the link,
long after the ASSERT is checked. An ASSERT referencing a PROVIDED but
not yet evaluated symbol will automatically fail.
FIXME: It would be nice if this value could be automatically set via
gcc's -fstack-usage command line option somehow. */
PROVIDE (__stack_size = 0x100);
/* Note: We place the stack in HIFRAM because then there is less
chance that it will collide with allocated data in the RAM region.
In scripts targeted at real MCUs however it may be better to place
the stack and heap in RAM, as flash does have a limited number of
writes before failure.
Note - if the location of .stack is changed, then be sure to change
the definition of .heap_start above as well. */
.stack (ORIGIN (HIFRAM) + LENGTH (HIFRAM)) :
{
PROVIDE (__stack = .);
/* Linker section checking ignores empty sections like
this one so we have to have our own test here. */
ASSERT ((__stack > (_end + __stack_size)),
"Error: Too much data - no room left for the stack");
}
.text :
{
PROVIDE (_start = .);
. = ALIGN(2);
KEEP (*(SORT(.crt_*)))
. = ALIGN(2);
KEEP (*(.lowtext))
. = ALIGN(2);
*(.lower.text.* .lower.text)
. = ALIGN(2);
*(.text .stub .text.* .gnu.linkonce.t.* .text:*)
/* See the note in .rodata section about why we do not have this line here:
*(.either.text.* .either.text)
*/
KEEP (*(.text.*personality*))
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
*(.interp .hash .dynsym .dynstr .gnu.version*)
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
. = ALIGN(2);
KEEP (*(.tm_clone_table))
} > ROM
.upper.text :
{
/* Note - if this section is not going to be included in the script
then please add this line back into the definition of the .text
section above:
*(.either.text.* .either.text)
*/
. = ALIGN(2);
*(.upper.text.* .upper.text)
} > HIROM
/* The rest are all not normally part of the runtime image. */
.MSP430.attributes 0 :
{
KEEP (*(.MSP430.attributes))
KEEP (*(.gnu.attributes))
KEEP (*(__TI_build_attributes))
}
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1. */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions. */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2. */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2. */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions. */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
/DISCARD/ : { *(.note.GNU-stack) }
}