[deliverable/binutils-gdb.git] / ld / scripttempl / elf32msp430.sc

# Copyright (C) 2014-2015 Free Software Foundation, Inc.
# 
# Copying and distribution of this file, with or without modification,
# are permitted in any medium without royalty provided the copyright
# notice and this notice are preserved.

HEAP_SECTION_MSP430=" "
HEAP_MEMORY_MSP430=" "

if test ${GOT_HEAP_MSP-0} -ne 0 
then 
HEAP_SECTION_MSP430=".heap ${RELOCATING-0} :
  {
    ${RELOCATING+ PROVIDE (__heap_data_start = .) ; }
    *(.heap*)
    ${RELOCATING+ PROVIDE (_heap_data_end = .) ; }
    ${RELOCATING+. = ALIGN(2);}
    ${RELOCATING+ PROVIDE (__heap_bottom = .) ; }
    ${RELOCATING+ PROVIDE (__heap_top = ${HEAP_START} + ${HEAP_LENGTH}) ; }
  } ${RELOCATING+ > heap}"
HEAP_MEMORY_MSP430="heap(rwx) 		: ORIGIN = $HEAP_START,	LENGTH = $HEAP_LENGTH"
fi


cat <<EOF
/* Copyright (C) 2014-2015 Free Software Foundation, Inc.

   Copying and distribution of this script, with or without modification,
   are permitted in any medium without royalty provided the copyright
   notice and this notice are preserved.  */

OUTPUT_FORMAT("${OUTPUT_FORMAT}","${OUTPUT_FORMAT}","${OUTPUT_FORMAT}")
OUTPUT_ARCH(${ARCH})

MEMORY
{
  text   (rx)   	: ORIGIN = $ROM_START,  LENGTH = $ROM_SIZE
  data   (rwx)  	: ORIGIN = $RAM_START, 	LENGTH = $RAM_SIZE
  vectors (rw)  	: ORIGIN = 0xffe0,      LENGTH = 0x20
  bootloader(rx)	: ORIGIN = 0x0c00,	LENGTH = 1K
  infomem(rx)		: ORIGIN = 0x1000,	LENGTH = 256
  infomemnobits(rx)	: ORIGIN = 0x1000,      LENGTH = 256
  ${HEAP_MEMORY_MSP430}
}

SECTIONS
{
  /* Bootloader.  */
  .bootloader ${RELOCATING-0} :
  {
    ${RELOCATING+ PROVIDE (__boot_start = .) ; }
    *(.bootloader)
    ${RELOCATING+. = ALIGN(2);}
    *(.bootloader.*)
  } ${RELOCATING+ > bootloader}
  
  /* Information memory.  */
  .infomem ${RELOCATING-0} :
  {
    *(.infomem)
    ${RELOCATING+. = ALIGN(2);}
    *(.infomem.*)
  } ${RELOCATING+ > infomem}

  /* Information memory (not loaded into MPU).  */
  .infomemnobits ${RELOCATING-0} :
  {
    *(.infomemnobits)
    ${RELOCATING+. = ALIGN(2);}
    *(.infomemnobits.*)
  } ${RELOCATING+ > infomemnobits}

  /* Read-only sections, merged into text segment.  */
  ${TEXT_DYNAMIC+${DYNAMIC}}
  .hash        ${RELOCATING-0} : { *(.hash)             }
  .dynsym      ${RELOCATING-0} : { *(.dynsym)           }
  .dynstr      ${RELOCATING-0} : { *(.dynstr)           }
  .gnu.version ${RELOCATING-0} : { *(.gnu.version)      }
  .gnu.version_d ${RELOCATING-0} : { *(.gnu.version_d)  }
  .gnu.version_r ${RELOCATING-0} : { *(.gnu.version_r)  }

  .rel.init    ${RELOCATING-0} : { *(.rel.init) }
  .rela.init   ${RELOCATING-0} : { *(.rela.init) }
  .rel.text    ${RELOCATING-0} :
    {
      *(.rel.text)
      ${RELOCATING+*(.rel.text.*)}
      ${RELOCATING+*(.rel.gnu.linkonce.t*)}
    }
  .rela.text   ${RELOCATING-0} :
    {
      *(.rela.text)
      ${RELOCATING+*(.rela.text.*)}
      ${RELOCATING+*(.rela.gnu.linkonce.t*)}
    }
  .rel.fini    ${RELOCATING-0} : { *(.rel.fini) }
  .rela.fini   ${RELOCATING-0} : { *(.rela.fini) }
  .rel.rodata  ${RELOCATING-0} :
    {
      *(.rel.rodata)
      ${RELOCATING+*(.rel.rodata.*)}
      ${RELOCATING+*(.rel.gnu.linkonce.r*)}
    }
  .rela.rodata ${RELOCATING-0} :
    {
      *(.rela.rodata)
      ${RELOCATING+*(.rela.rodata.*)}
      ${RELOCATING+*(.rela.gnu.linkonce.r*)}
    }
  .rel.data    ${RELOCATING-0} :
    {
      *(.rel.data)
      ${RELOCATING+*(.rel.data.*)}
      ${RELOCATING+*(.rel.gnu.linkonce.d*)}
    }
  .rela.data   ${RELOCATING-0} :
    {
      *(.rela.data)
      ${RELOCATING+*(.rela.data.*)}
      ${RELOCATING+*(.rela.gnu.linkonce.d*)}
    }
  .rel.ctors   ${RELOCATING-0} : { *(.rel.ctors)        }
  .rela.ctors  ${RELOCATING-0} : { *(.rela.ctors)       }
  .rel.dtors   ${RELOCATING-0} : { *(.rel.dtors)        }
  .rela.dtors  ${RELOCATING-0} : { *(.rela.dtors)       }
  .rel.got     ${RELOCATING-0} : { *(.rel.got)          }
  .rela.got    ${RELOCATING-0} : { *(.rela.got)         }
  .rel.bss     ${RELOCATING-0} : { *(.rel.bss)          }
  .rela.bss    ${RELOCATING-0} : { *(.rela.bss)         }
  .rel.plt     ${RELOCATING-0} : { *(.rel.plt)          }
  .rela.plt    ${RELOCATING-0} : { *(.rela.plt)         }

  /* Internal text space.  */
  .text :
  {
    ${RELOCATING+. = ALIGN(2);}
    *(SORT_NONE(.init))
    *(SORT_NONE(.init0))  /* Start here after reset.  */
    *(SORT_NONE(.init1))
    *(SORT_NONE(.init2))  /* Copy data loop  */
    *(SORT_NONE(.init3))
    *(SORT_NONE(.init4))  /* Clear bss  */
    *(SORT_NONE(.init5))
    *(SORT_NONE(.init6))  /* C++ constructors.  */
    *(SORT_NONE(.init7))
    *(SORT_NONE(.init8))
    *(SORT_NONE(.init9))  /* Call main().  */

    ${CONSTRUCTING+ __ctors_start = . ; }
    ${CONSTRUCTING+ *(.ctors) }
    ${CONSTRUCTING+ __ctors_end = . ; }
    ${CONSTRUCTING+ __dtors_start = . ; }
    ${CONSTRUCTING+ *(.dtors) }
    ${CONSTRUCTING+ __dtors_end = . ; }

    ${RELOCATING+. = ALIGN(2);}
    *(.lower.text.* .lower.text)

    ${RELOCATING+. = ALIGN(2);}
    *(.text)
    ${RELOCATING+. = ALIGN(2);}
    *(.text.*)
    ${RELOCATING+. = ALIGN(2);}
    *(.text:*)

    *(.either.text.* .either.text)

    ${RELOCATING+. = ALIGN(2);}
    *(SORT_NONE(.fini9))
    *(SORT_NONE(.fini8))
    *(SORT_NONE(.fini7))
    *(SORT_NONE(.fini6))  /* C++ destructors.  */
    *(SORT_NONE(.fini5))
    *(SORT_NONE(.fini4))
    *(SORT_NONE(.fini3))
    *(SORT_NONE(.fini2))
    *(SORT_NONE(.fini1))
    *(SORT_NONE(.fini0))  /* Infinite loop after program termination.  */
    *(SORT_NONE(.fini))

    _etext = .;
  } ${RELOCATING+ > text}

  .rodata :
  {
    ${RELOCATING+. = ALIGN(2);}
    *(.lower.rodata.* .lower.rodata)

    . = ALIGN(2);
    *(.plt)
    *(.rodata .rodata.* .gnu.linkonce.r.* .const .const:*)
    *(.rodata1)

    *(.either.rodata.*) *(.either.rodata)
    *(.eh_frame_hdr)
    KEEP (*(.eh_frame))

    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 = .);
    LONG(0); /* Sentinel.  */

    /* 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))
  } ${RELOCATING+ > text}

  .vectors ${RELOCATING-0}:
  {
    ${RELOCATING+ PROVIDE (__vectors_start = .) ; }
    *(.vectors*)
    ${RELOCATING+ _vectors_end = . ; }
  } ${RELOCATING+ > vectors}

  .data ${RELOCATING-0} :
  {
    ${RELOCATING+ PROVIDE (__data_start = .) ; }
    ${RELOCATING+ PROVIDE (__datastart = .) ; }
    ${RELOCATING+. = ALIGN(2);}

    KEEP (*(.jcr))
    *(.data.rel.ro.local) *(.data.rel.ro*)
    *(.dynamic)

    ${RELOCATING+. = ALIGN(2);}
    *(.lower.data.* .lower.data)

    *(.data)
    *(.data.*)
    *(.gnu.linkonce.d*)
    KEEP (*(.gnu.linkonce.d.*personality*))
    *(.data1)

    *(.either.data.* .either.data)

    *(.got.plt) *(.got)
    ${RELOCATING+. = ALIGN(2);}
    *(.sdata .sdata.* .gnu.linkonce.s.*)
    ${RELOCATING+. = ALIGN(2);}
    ${RELOCATING+ _edata = . ; }
  } ${RELOCATING+ > data ${RELOCATING+AT> text}}

  .bss ${RELOCATING+ SIZEOF(.data) + ADDR(.data)} :
  {
    ${RELOCATING+. = ALIGN(2);}
    ${RELOCATING+ PROVIDE (__bss_start = .) ; }
    *(.lower.bss.* .lower.bss)
    ${RELOCATING+. = ALIGN(2);}
    *(.bss)
    *(.either.bss.* .either.bss)
    *(COMMON)
    ${RELOCATING+ PROVIDE (__bss_end = .) ; }
  } ${RELOCATING+ > data}

  .noinit ${RELOCATING+ SIZEOF(.bss) + ADDR(.bss)} :
  {
    ${RELOCATING+ PROVIDE (__noinit_start = .) ; }
    *(.noinit)
    ${RELOCATING+ PROVIDE (__noinit_end = .) ; }
  } ${RELOCATING+ > data}

  .persistent ${RELOCATING+ SIZEOF(.noinit) + ADDR(.noinit)} :
  {
    ${RELOCATING+ PROVIDE (__persistent_start = .) ; }
    *(.persistent)
    ${RELOCATING+ PROVIDE (__persistent_end = .) ; }
  } ${RELOCATING+ > data}

  ${RELOCATING+ _end = . ;  }
  ${HEAP_SECTION_MSP430}

  /* Stabs for profiling information*/
  .profiler 0 : { *(.profiler) }
  
  /* 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) }
EOF

source $srcdir/scripttempl/DWARF.sc

cat <<EOF
  .MP430.attributes 0 :
  {
    KEEP (*(.MSP430.attributes))
    KEEP (*(.gnu.attributes))
    KEEP (*(__TI_build_attributes))
  }

  PROVIDE (__stack = ${STACK}) ;
  PROVIDE (__data_start_rom = _etext) ;
  PROVIDE (__data_end_rom   = _etext + SIZEOF (.data)) ;
  PROVIDE (__noinit_start_rom = _etext + SIZEOF (.data)) ;
  PROVIDE (__noinit_end_rom = _etext + SIZEOF (.data) + SIZEOF (.noinit)) ;
  PROVIDE (__subdevice_has_heap = ${GOT_HEAP_MSP-0}) ;
}
EOF
Commit	Line	Data
b90efa5b	1	# Copyright (C) 2014-2015 Free Software Foundation, Inc.
985743c7 NC	2	#
	3	# Copying and distribution of this file, with or without modification,
	4	# are permitted in any medium without royalty provided the copyright
	5	# notice and this notice are preserved.
f2f489ac NC	6
	7	HEAP_SECTION_MSP430=" "
	8	HEAP_MEMORY_MSP430=" "
	9
	10	if test ${GOT_HEAP_MSP-0} -ne 0
	11	then
ec2d9b29	12	HEAP_SECTION_MSP430=".heap ${RELOCATING-0} :
f2f489ac NC	13	{
	14	${RELOCATING+ PROVIDE (__heap_data_start = .) ; }
	15	(.heap)
	16	${RELOCATING+ PROVIDE (_heap_data_end = .) ; }
	17	${RELOCATING+. = ALIGN(2);}
	18	${RELOCATING+ PROVIDE (__heap_bottom = .) ; }
	19	${RELOCATING+ PROVIDE (__heap_top = ${HEAP_START} + ${HEAP_LENGTH}) ; }
	20	} ${RELOCATING+ > heap}"
	21	HEAP_MEMORY_MSP430="heap(rwx) : ORIGIN = $HEAP_START, LENGTH = $HEAP_LENGTH"
	22	fi
	23
	24
2469cfa2	25	cat <<EOF
b90efa5b	26	/* Copyright (C) 2014-2015 Free Software Foundation, Inc.
985743c7 NC	27
	28	Copying and distribution of this script, with or without modification,
	29	are permitted in any medium without royalty provided the copyright
	30	notice and this notice are preserved. */
	31
2469cfa2 NC	32	OUTPUT_FORMAT("${OUTPUT_FORMAT}","${OUTPUT_FORMAT}","${OUTPUT_FORMAT}")
	33	OUTPUT_ARCH(${ARCH})
	34
	35	MEMORY
	36	{
	37	text (rx) : ORIGIN = $ROM_START, LENGTH = $ROM_SIZE
	38	data (rwx) : ORIGIN = $RAM_START, LENGTH = $RAM_SIZE
	39	vectors (rw) : ORIGIN = 0xffe0, LENGTH = 0x20
	40	bootloader(rx) : ORIGIN = 0x0c00, LENGTH = 1K
	41	infomem(rx) : ORIGIN = 0x1000, LENGTH = 256
	42	infomemnobits(rx) : ORIGIN = 0x1000, LENGTH = 256
f2f489ac	43	${HEAP_MEMORY_MSP430}
2469cfa2 NC	44	}
	45
	46	SECTIONS
	47	{
13761a11 NC	48	/* Bootloader. */
	49	.bootloader ${RELOCATING-0} :
	50	{
	51	${RELOCATING+ PROVIDE (__boot_start = .) ; }
	52	*(.bootloader)
	53	${RELOCATING+. = ALIGN(2);}
	54	(.bootloader.)
	55	} ${RELOCATING+ > bootloader}
	56
	57	/* Information memory. */
	58	.infomem ${RELOCATING-0} :
	59	{
	60	*(.infomem)
	61	${RELOCATING+. = ALIGN(2);}
	62	(.infomem.)
	63	} ${RELOCATING+ > infomem}
	64
	65	/* Information memory (not loaded into MPU). */
	66	.infomemnobits ${RELOCATING-0} :
	67	{
	68	*(.infomemnobits)
	69	${RELOCATING+. = ALIGN(2);}
	70	(.infomemnobits.)
	71	} ${RELOCATING+ > infomemnobits}
	72
2469cfa2 NC	73	/* Read-only sections, merged into text segment. */
2469cfa2 NC	74	${TEXT_DYNAMIC+${DYNAMIC}}
ec2d9b29 AM	75	.hash ${RELOCATING-0} : { *(.hash) }
	76	.dynsym ${RELOCATING-0} : { *(.dynsym) }
	77	.dynstr ${RELOCATING-0} : { *(.dynstr) }
	78	.gnu.version ${RELOCATING-0} : { *(.gnu.version) }
	79	.gnu.version_d ${RELOCATING-0} : { *(.gnu.version_d) }
	80	.gnu.version_r ${RELOCATING-0} : { *(.gnu.version_r) }
	81
	82	.rel.init ${RELOCATING-0} : { *(.rel.init) }
	83	.rela.init ${RELOCATING-0} : { *(.rela.init) }
	84	.rel.text ${RELOCATING-0} :
2469cfa2 NC	85	{
	86	*(.rel.text)
	87	${RELOCATING+(.rel.text.)}
	88	${RELOCATING+(.rel.gnu.linkonce.t)}
	89	}
ec2d9b29	90	.rela.text ${RELOCATING-0} :
2469cfa2 NC	91	{
	92	*(.rela.text)
	93	${RELOCATING+(.rela.text.)}
	94	${RELOCATING+(.rela.gnu.linkonce.t)}
	95	}
ec2d9b29 AM	96	.rel.fini ${RELOCATING-0} : { *(.rel.fini) }
	97	.rela.fini ${RELOCATING-0} : { *(.rela.fini) }
	98	.rel.rodata ${RELOCATING-0} :
2469cfa2 NC	99	{
	100	*(.rel.rodata)
	101	${RELOCATING+(.rel.rodata.)}
	102	${RELOCATING+(.rel.gnu.linkonce.r)}
	103	}
ec2d9b29	104	.rela.rodata ${RELOCATING-0} :
2469cfa2 NC	105	{
	106	*(.rela.rodata)
	107	${RELOCATING+(.rela.rodata.)}
	108	${RELOCATING+(.rela.gnu.linkonce.r)}
	109	}
ec2d9b29	110	.rel.data ${RELOCATING-0} :
2469cfa2 NC	111	{
	112	*(.rel.data)
	113	${RELOCATING+(.rel.data.)}
	114	${RELOCATING+(.rel.gnu.linkonce.d)}
	115	}
ec2d9b29	116	.rela.data ${RELOCATING-0} :
2469cfa2 NC	117	{
	118	*(.rela.data)
	119	${RELOCATING+(.rela.data.)}
	120	${RELOCATING+(.rela.gnu.linkonce.d)}
	121	}
ec2d9b29 AM	122	.rel.ctors ${RELOCATING-0} : { *(.rel.ctors) }
	123	.rela.ctors ${RELOCATING-0} : { *(.rela.ctors) }
	124	.rel.dtors ${RELOCATING-0} : { *(.rel.dtors) }
	125	.rela.dtors ${RELOCATING-0} : { *(.rela.dtors) }
	126	.rel.got ${RELOCATING-0} : { *(.rel.got) }
	127	.rela.got ${RELOCATING-0} : { *(.rela.got) }
	128	.rel.bss ${RELOCATING-0} : { *(.rel.bss) }
	129	.rela.bss ${RELOCATING-0} : { *(.rela.bss) }
	130	.rel.plt ${RELOCATING-0} : { *(.rel.plt) }
	131	.rela.plt ${RELOCATING-0} : { *(.rela.plt) }
2469cfa2 NC	132
	133	/* Internal text space. */
	134	.text :
	135	{
d4b6ee67	136	${RELOCATING+. = ALIGN(2);}
b2e4da5a L	137	*(SORT_NONE(.init))
	138	(SORT_NONE(.init0)) / Start here after reset. */
	139	*(SORT_NONE(.init1))
	140	(SORT_NONE(.init2)) / Copy data loop */
	141	*(SORT_NONE(.init3))
	142	(SORT_NONE(.init4)) / Clear bss */
	143	*(SORT_NONE(.init5))
	144	(SORT_NONE(.init6)) / C++ constructors. */
	145	*(SORT_NONE(.init7))
	146	*(SORT_NONE(.init8))
	147	(SORT_NONE(.init9)) / Call main(). */
d4b6ee67 NC	148
	149	${CONSTRUCTING+ __ctors_start = . ; }
	150	${CONSTRUCTING+ *(.ctors) }
	151	${CONSTRUCTING+ __ctors_end = . ; }
	152	${CONSTRUCTING+ __dtors_start = . ; }
	153	${CONSTRUCTING+ *(.dtors) }
	154	${CONSTRUCTING+ __dtors_end = . ; }
	155
837a17b3 NC	156	${RELOCATING+. = ALIGN(2);}
	157	(.lower.text. .lower.text)
	158
2469cfa2 NC	159	${RELOCATING+. = ALIGN(2);}
	160	*(.text)
	161	${RELOCATING+. = ALIGN(2);}
	162	(.text.)
13761a11 NC	163	${RELOCATING+. = ALIGN(2);}
13761a11 NC	164	(.text:)
d4b6ee67	165
837a17b3 NC	166	(.either.text. .either.text)
837a17b3 NC	167
2469cfa2	168	${RELOCATING+. = ALIGN(2);}
b2e4da5a L	169	*(SORT_NONE(.fini9))
	170	*(SORT_NONE(.fini8))
	171	*(SORT_NONE(.fini7))
	172	(SORT_NONE(.fini6)) / C++ destructors. */
	173	*(SORT_NONE(.fini5))
	174	*(SORT_NONE(.fini4))
	175	*(SORT_NONE(.fini3))
	176	*(SORT_NONE(.fini2))
	177	*(SORT_NONE(.fini1))
	178	(SORT_NONE(.fini0)) / Infinite loop after program termination. */
	179	*(SORT_NONE(.fini))
d4b6ee67	180
f2f489ac	181	_etext = .;
2469cfa2 NC	182	} ${RELOCATING+ > text}
2469cfa2 NC	183
13761a11 NC	184	.rodata :
13761a11 NC	185	{
837a17b3 NC	186	${RELOCATING+. = ALIGN(2);}
	187	(.lower.rodata. .lower.rodata)
	188
13761a11 NC	189	. = ALIGN(2);
	190	*(.plt)
	191	(.rodata .rodata. .gnu.linkonce.r.* .const .const:*)
	192	*(.rodata1)
	193
837a17b3	194	(.either.rodata.) *(.either.rodata)
13761a11 NC	195	*(.eh_frame_hdr)
	196	KEEP (*(.eh_frame))
	197
	198	KEEP ((.gcc_except_table)) (.gcc_except_table.*)
	199
	200	PROVIDE (__preinit_array_start = .);
	201	KEEP (*(.preinit_array))
	202	PROVIDE (__preinit_array_end = .);
	203
	204	PROVIDE (__init_array_start = .);
	205	KEEP ((SORT(.init_array.)))
	206	KEEP (*(.init_array))
	207	PROVIDE (__init_array_end = .);
	208
	209	PROVIDE (__fini_array_start = .);
	210	KEEP (*(.fini_array))
	211	KEEP ((SORT(.fini_array.)))
	212	PROVIDE (__fini_array_end = .);
	213	LONG(0); /* Sentinel. */
	214
	215	/* gcc uses crtbegin.o to find the start of the constructors, so
	216	we make sure it is first. Because this is a wildcard, it
	217	doesn't matter if the user does not actually link against
	218	crtbegin.o; the linker won't look for a file to match a
	219	wildcard. The wildcard also means that it doesn't matter which
	220	directory crtbegin.o is in. */
	221	KEEP (crtbegin.o(.ctors))
	222
	223	/* We don't want to include the .ctor section from from the
	224	crtend.o file until after the sorted ctors. The .ctor section
	225	from the crtend file contains the end of ctors marker and it
	226	must be last */
	227	KEEP ((EXCLUDE_FILE (crtend*.o ) .ctors))
	228	KEEP ((SORT(.ctors.)))
	229	KEEP (*(.ctors))
	230
	231	KEEP (crtbegin.o(.dtors))
	232	KEEP ((EXCLUDE_FILE (crtend*.o ) .dtors))
	233	KEEP ((SORT(.dtors.)))
	234	KEEP (*(.dtors))
	235	} ${RELOCATING+ > text}
	236
	237	.vectors ${RELOCATING-0}:
	238	{
	239	${RELOCATING+ PROVIDE (__vectors_start = .) ; }
	240	(.vectors)
	241	${RELOCATING+ _vectors_end = . ; }
	242	} ${RELOCATING+ > vectors}
	243
925bbbbb NC	244	.data ${RELOCATING-0} :
925bbbbb NC	245	{
2469cfa2	246	${RELOCATING+ PROVIDE (__data_start = .) ; }
13761a11	247	${RELOCATING+ PROVIDE (__datastart = .) ; }
2469cfa2	248	${RELOCATING+. = ALIGN(2);}
13761a11 NC	249
	250	KEEP (*(.jcr))
	251	(.data.rel.ro.local) (.data.rel.ro*)
	252	*(.dynamic)
	253
837a17b3 NC	254	${RELOCATING+. = ALIGN(2);}
	255	(.lower.data. .lower.data)
	256
2469cfa2	257	*(.data)
727f7031	258	(.data.)
2469cfa2	259	(.gnu.linkonce.d)
13761a11 NC	260	KEEP ((.gnu.linkonce.d.personality*))
13761a11 NC	261	*(.data1)
837a17b3 NC	262
	263	(.either.data. .either.data)
	264
13761a11 NC	265	(.got.plt) (.got)
	266	${RELOCATING+. = ALIGN(2);}
	267	(.sdata .sdata. .gnu.linkonce.s.*)
2469cfa2 NC	268	${RELOCATING+. = ALIGN(2);}
2469cfa2 NC	269	${RELOCATING+ _edata = . ; }
925bbbbb	270	} ${RELOCATING+ > data ${RELOCATING+AT> text}}
837a17b3	271
2469cfa2 NC	272	.bss ${RELOCATING+ SIZEOF(.data) + ADDR(.data)} :
2469cfa2 NC	273	{
727f7031	274	${RELOCATING+. = ALIGN(2);}
2469cfa2	275	${RELOCATING+ PROVIDE (__bss_start = .) ; }
837a17b3 NC	276	(.lower.bss. .lower.bss)
837a17b3 NC	277	${RELOCATING+. = ALIGN(2);}
2469cfa2	278	*(.bss)
837a17b3	279	(.either.bss. .either.bss)
2469cfa2 NC	280	*(COMMON)
2469cfa2 NC	281	${RELOCATING+ PROVIDE (__bss_end = .) ; }
2469cfa2 NC	282	} ${RELOCATING+ > data}
	283
	284	.noinit ${RELOCATING+ SIZEOF(.bss) + ADDR(.bss)} :
	285	{
	286	${RELOCATING+ PROVIDE (__noinit_start = .) ; }
	287	*(.noinit)
2469cfa2	288	${RELOCATING+ PROVIDE (__noinit_end = .) ; }
2469cfa2 NC	289	} ${RELOCATING+ > data}
2469cfa2 NC	290
886a2506 NC	291	.persistent ${RELOCATING+ SIZEOF(.noinit) + ADDR(.noinit)} :
	292	{
	293	${RELOCATING+ PROVIDE (__persistent_start = .) ; }
	294	*(.persistent)
	295	${RELOCATING+ PROVIDE (__persistent_end = .) ; }
	296	} ${RELOCATING+ > data}
	297
	298	${RELOCATING+ _end = . ; }
f2f489ac	299	${HEAP_SECTION_MSP430}
2469cfa2	300
b18c562e NC	301	/* Stabs for profiling information*/
	302	.profiler 0 : { *(.profiler) }
	303
2469cfa2 NC	304	/* Stabs debugging sections. */
	305	.stab 0 : { *(.stab) }
	306	.stabstr 0 : { *(.stabstr) }
	307	.stab.excl 0 : { *(.stab.excl) }
	308	.stab.exclstr 0 : { *(.stab.exclstr) }
	309	.stab.index 0 : { *(.stab.index) }
	310	.stab.indexstr 0 : { *(.stab.indexstr) }
	311	.comment 0 : { *(.comment) }
ceb0a680	312	EOF
2a995fc1	313
13761a11	314	source $srcdir/scripttempl/DWARF.sc
2a995fc1	315
ceb0a680	316	cat <<EOF
13761a11 NC	317	.MP430.attributes 0 :
	318	{
	319	KEEP (*(.MSP430.attributes))
	320	KEEP (*(.gnu.attributes))
	321	KEEP (*(__TI_build_attributes))
	322	}
	323
2469cfa2	324	PROVIDE (__stack = ${STACK}) ;
db6a5910 NC	325	PROVIDE (__data_start_rom = _etext) ;
	326	PROVIDE (__data_end_rom = _etext + SIZEOF (.data)) ;
	327	PROVIDE (__noinit_start_rom = _etext + SIZEOF (.data)) ;
	328	PROVIDE (__noinit_end_rom = _etext + SIZEOF (.data) + SIZEOF (.noinit)) ;
f2f489ac	329	PROVIDE (__subdevice_has_heap = ${GOT_HEAP_MSP-0}) ;
2469cfa2 NC	330	}
2469cfa2 NC	331	EOF