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

# Copyright (C) 2014-2020 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-2020 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})

EOF

test -n "${RELOCATING}" && cat <<EOF
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}
}

EOF

cat <<EOF
SECTIONS
{
  /* Bootloader.  */
  .bootloader ${RELOCATING-0} :
  {
    ${RELOCATING+ PROVIDE (__boot_start = .) ; }
    *(.bootloader)
    ${RELOCATING+. = ALIGN(2);}
    ${RELOCATING+*(.bootloader.*)}
  } ${RELOCATING+ > bootloader}

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

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

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

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

    . = 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-0} :
  {
    ${RELOCATING+. = ALIGN(2);
    *(.lower.rodata.* .lower.rodata)

    . = ALIGN(2);
    *(.plt)}
    *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.* .const .const:*})
    ${RELOCATING+*(.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 = .);

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

    . = ALIGN(2);
    *(.lower.data.* .lower.data)}

    *(.data)
    ${RELOCATING+*(.data.*)
    *(.gnu.linkonce.d*)
    KEEP (*(.gnu.linkonce.d.*personality*))
    *(.data1)

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

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

  ${RELOCATING+__romdatastart = LOADADDR(.data);
  __romdatacopysize = SIZEOF(.data);}

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

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

  .persistent ${RELOCATING-0}${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

. $srcdir/scripttempl/DWARF.sc

test -n "${RELOCATING}" && cat <<EOF
  .MSP430.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

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