RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

Eric Norum <eric@cls.usask.ca> submitted linker script and bsp_specs

Browse Source 
for the gen68360 that let it work with ELF and C++ exceptions.  This
was used as the basis for changes to EVERY m68k bsp_specs and linkcmds.
Before this modification is over, the layout of the starting stack,
heap, and workspace will likely be modified for every m68k BSP. Then
they will all be very similar.
This commit is contained in:
Joel Sherrill
2000-01-12 16:38:57 +00:00
parent 69537ca9ec
commit b2b4835718
26 changed files with 1415 additions and 756 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
c/src/lib/libbsp/m68k/dmv152/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

155
c/src/lib/libbsp/m68k/dmv152/startup/linkcmds
View File

@@ -12,62 +12,123 @@
* $Id$ * $Id$
*/ */
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000; StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
MEMORY MEMORY
{ {
ram : org = 0x12800, l = 1M ram : org = 0x0, l = 1M
} }
SECTIONS SECTIONS
{ {
.text 0x12800 : ram : {
{ . = 0x12800;
text_start = . ; } >ram
_text_start = . ;
*(.text)
. = ALIGN (16);
*(.eh_fram) /*
. = ALIGN (16); * Text, data and bss segments
*/
.text : {
*(.text)
. = ALIGN (16); /*
*(.gcc_exc) * C++ constructors/destructors
*/
*(.gnu.linkonce.t.*)
/* /*
* C++ constructors * Initialization and finalization code.
*/ *
__CTOR_LIST__ = .; * Various files can provide initialization and finalization
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2) * functions. crtbegin.o and crtend.o are two instances. The
*(.ctors) * body of these functions are in .init and .fini sections. We
LONG(0) * accumulate the bodies here, and prepend function prologues
__CTOR_END__ = .; * from crti.o and function epilogues from crtn.o. crti.o must
__DTOR_LIST__ = .; * be linked first; crtn.o must be linked last. Because these
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) * are wildcards, it doesn't matter if the user does not
*(.dtors) * actually link against crti.o and crtn.o; the linker won't
LONG(0) * look for a file to match a wildcard. The wildcard also
__DTOR_END__ = .; * means that it doesn't matter which directory crti.o and
etext = ALIGN( 0x10 ) ; * crtn.o are in.
_etext = .; */
} PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
/*
.data : { * C++ constructors/destructors
data_start = . ; *
_data_start = . ; * gcc uses crtbegin.o to find the start of the constructors
*(.data) * and destructors so we make sure it is first. Because this
edata = ALIGN( 0x10 ) ; * is a wildcard, it doesn't matter if the user does not
_edata = .; * actually link against crtbegin.o; the linker won't look for
} * a file to match a wildcard. The wildcard also means that
.bss : { * it doesn't matter which directory crtbegin.o is in. The
bss_start = . ; * constructor and destructor list are terminated in
_bss_start = . ; * crtend.o. The same comments apply to it.
*(.bss) */
*(COMMON)
. += StackSize; /* XXX -- Old gld can't handle this */
. = ALIGN (16); . = ALIGN (16);
stack_init = .; *crtbegin.o(.ctors)
end = . ; *(.ctors)
_end = . ; *crtend.o(.ctors)
} *crtbegin.o(.dtors)
*(.dtors)
*crtend.o(.dtors)
/*
* Exception frame info
*/
. = ALIGN (16);
*(.eh_frame)
/*
* Read-only data
*/
. = ALIGN (16);
_rodata_start = . ;
*(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (etext = .);
} >ram
.data : {
copy_start = .;
*(.data)
*(.gnu.linkonce.d*)
*(.gcc_except_table)
. = ALIGN (16);
PROVIDE (_edata = .);
copy_end = .;
} >ram
.bss : {
bss_start = .;
. += (256 * 4);
clear_start = .;
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
_WorkspaceBase = .;
} >ram
} }

6
c/src/lib/libbsp/m68k/efi332/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

170
c/src/lib/libbsp/m68k/efi332/startup/linkcmds
View File

@@ -30,6 +30,12 @@ __DYNAMIC = 0;
* +--------------------+ <- high memory * +--------------------+ <- high memory
*/ */
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
MEMORY MEMORY
{ {
ram : ORIGIN = 0x80000, LENGTH = 512K ram : ORIGIN = 0x80000, LENGTH = 512K
@@ -43,69 +49,109 @@ _copy_data_from_rom = 0;
*/ */
SECTIONS SECTIONS
{ {
.text : ram : {
{ . = .;
CREATE_OBJECT_SYMBOLS } >ram
text_start = .;
_text_start = .;
*(.text) /*
. = ALIGN (16); * Text, data and bss segments
*/
.text : {
*(.text)
*(.eh_fram) /*
. = ALIGN (16); * C++ constructors/destructors
*/
*(.gnu.linkonce.t.*)
etext = ALIGN(0x10); /*
_etext = .; * Initialization and finalization code.
__CTOR_LIST__ = .; *
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2) * Various files can provide initialization and finalization
*(.ctors) * functions. crtbegin.o and crtend.o are two instances. The
LONG(0) * body of these functions are in .init and .fini sections. We
__CTOR_END__ = .; * accumulate the bodies here, and prepend function prologues
__DTOR_LIST__ = .; * from crti.o and function epilogues from crtn.o. crti.o must
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) * be linked first; crtn.o must be linked last. Because these
*(.dtors) * are wildcards, it doesn't matter if the user does not
LONG(0) * actually link against crti.o and crtn.o; the linker won't
__DTOR_END__ = .; * look for a file to match a wildcard. The wildcard also
*(.lit) * means that it doesn't matter which directory crti.o and
*(.shdata) * crtn.o are in.
_endtext = .; */
} > ram PROVIDE (_init = .);
.gcc_exc : *crti.o(.init)
{ *(.init)
*(.gcc_exc) *crtn.o(.init)
} > ram PROVIDE (_fini = .);
.data : *crti.o(.fini)
{ *(.fini)
data_start = .; *crtn.o(.fini)
_data_start = .;
_sdata = . ; /*
*(.data) * C++ constructors/destructors
CONSTRUCTORS *
edata = ALIGN(0x10); * gcc uses crtbegin.o to find the start of the constructors
_edata = .; * and destructors so we make sure it is first. Because this
} > ram * is a wildcard, it doesn't matter if the user does not
.shbss : * actually link against crtbegin.o; the linker won't look for
{ * a file to match a wildcard. The wildcard also means that
*(.shbss) * it doesn't matter which directory crtbegin.o is in. The
} > ram * constructor and destructor list are terminated in
.bss : * crtend.o. The same comments apply to it.
{ */
__bss_start = ALIGN(0x8); . = ALIGN (16);
bss_start = .; *crtbegin.o(.ctors)
_bss_start = .; *(.ctors)
*(.bss) *crtend.o(.ctors)
*(COMMON) *crtbegin.o(.dtors)
end = .; *(.dtors)
_end = ALIGN(0x8); *crtend.o(.dtors)
__end = ALIGN(0x8);
} > ram /*
.stab . (NOLOAD) : * Exception frame info
{ */
[ .stab ] . = ALIGN (16);
} *(.eh_frame)
.stabstr . (NOLOAD) :
{ /*
[ .stabstr ] * Read-only data
} */
. = ALIGN (16);
_rodata_start = . ;
*(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : {
PROVIDE (_copy_start = .);
*(.data)
*(.gnu.linkonce.d*)
*(.gcc_except_table)
. = ALIGN (16);
PROVIDE (_edata = .);
PROVIDE (_copy_end = .);
} >ram
.bss : {
PROVIDE (_bss_start = .);
PROVIDE (_clear_start = .);
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
} }

6
c/src/lib/libbsp/m68k/efi68k/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

169
c/src/lib/libbsp/m68k/efi68k/startup/linkcmds
View File

@@ -46,68 +46,121 @@ _VBR = 0x200000; /* location of the VBR table (in RAM) */
__end_of_ram = 0x240000; __end_of_ram = 0x240000;
_copy_data_from_rom = 0; _copy_data_from_rom = 0;
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
/* /*
* stick everything in ram (of course) * stick everything in ram (of course)
*/ */
SECTIONS SECTIONS
{ {
.text : ram : {
{ . = .;
CREATE_OBJECT_SYMBOLS } >ram
text_start = .;
_text_start = .;
*(.text)
. = ALIGN (16);
*(.eh_fram)
. = ALIGN (16);
etext = ALIGN(0x10); /*
_etext = .; * Text, data and bss segments
__CTOR_LIST__ = .; */
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2) .text : {
*(.ctors) *(.text)
LONG(0)
__CTOR_END__ = .; /*
__DTOR_LIST__ = .; * C++ constructors/destructors
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) */
*(.dtors) *(.gnu.linkonce.t.*)
LONG(0)
__DTOR_END__ = .; /*
*(.lit) * Initialization and finalization code.
*(.shdata) *
_endtext = .; * Various files can provide initialization and finalization
} > ram * functions. crtbegin.o and crtend.o are two instances. The
.data : * body of these functions are in .init and .fini sections. We
{ * accumulate the bodies here, and prepend function prologues
data_start = .; * from crti.o and function epilogues from crtn.o. crti.o must
_data_start = .; * be linked first; crtn.o must be linked last. Because these
_sdata = . ; * are wildcards, it doesn't matter if the user does not
*(.data) * actually link against crti.o and crtn.o; the linker won't
CONSTRUCTORS * look for a file to match a wildcard. The wildcard also
edata = ALIGN(0x10); * means that it doesn't matter which directory crti.o and
_edata = .; * crtn.o are in.
} > ram */
.shbss : PROVIDE (_init = .);
{ *crti.o(.init)
*(.shbss) *(.init)
} > ram *crtn.o(.init)
.bss : PROVIDE (_fini = .);
{ *crti.o(.fini)
__bss_start = ALIGN(0x8); *(.fini)
bss_start = .; *crtn.o(.fini)
_bss_start = .;
*(.bss) /*
*(COMMON) * C++ constructors/destructors
end = .; *
_end = ALIGN(0x8); * gcc uses crtbegin.o to find the start of the constructors
__end = ALIGN(0x8); * and destructors so we make sure it is first. Because this
} > ram * is a wildcard, it doesn't matter if the user does not
.stab . (NOLOAD) : * actually link against crtbegin.o; the linker won't look for
{ * a file to match a wildcard. The wildcard also means that
[ .stab ] * it doesn't matter which directory crtbegin.o is in. The
} * constructor and destructor list are terminated in
.stabstr . (NOLOAD) : * crtend.o. The same comments apply to it.
{ */
[ .stabstr ] . = ALIGN (16);
} *crtbegin.o(.ctors)
*(.ctors)
*crtend.o(.ctors)
*crtbegin.o(.dtors)
*(.dtors)
*crtend.o(.dtors)
/*
* Exception frame info
*/
. = ALIGN (16);
*(.eh_frame)
/*
* Read-only data
*/
. = ALIGN (16);
_rodata_start = . ;
*(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : {
PROVIDE (_copy_start = .);
*(.data)
*(.gnu.linkonce.d*)
*(.gcc_except_table)
. = ALIGN (16);
PROVIDE (_edata = .);
PROVIDE (_copy_end = .);
} >ram
.bss : {
PROVIDE (_bss_start = .);
PROVIDE (_clear_start = .);
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
} }

6
c/src/lib/libbsp/m68k/gen68302/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

157
c/src/lib/libbsp/m68k/gen68302/startup/linkcmds
View File

@@ -13,63 +13,124 @@
*/ */
MEMORY MEMORY
{ {
ram : org = 0x0000, l = 16M ram : org = 0x0000, l = 16M
} }
m302 = 0xf7f000; m302 = 0xf7f000;
_VBR = 0x000000; /* location of the VBR table (in RAM) */ _VBR = 0x000000; /* location of the VBR table (in RAM) */
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
SECTIONS SECTIONS
{ {
.text 0xc00000 : ram : {
{ . = 0xc00000;
text_start = . ; } >ram
*(.text)
. = ALIGN (16);
*(.gnu.linkonce.t.*)
*(.descriptors)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
*(.eh_fram) /*
. = ALIGN (16); * Text, data and bss segments
*/
.text : {
*(.text)
/* /*
* C++ constructors * C++ constructors/destructors
*/ */
__CTOR_LIST__ = .; *(.gnu.linkonce.t.*)
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
*(.ctors)
LONG(0)
__CTOR_END__ = .;
__DTOR_LIST__ = .;
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
*(.dtors)
LONG(0)
__DTOR_END__ = .;
_rodata_start = . ; /*
*(.rodata) * Initialization and finalization code.
*(.gnu.linkonce.r*) *
_erodata = ALIGN( 0x10 ) ; * Various files can provide initialization and finalization
* functions. crtbegin.o and crtend.o are two instances. The
* body of these functions are in .init and .fini sections. We
* accumulate the bodies here, and prepend function prologues
* from crti.o and function epilogues from crtn.o. crti.o must
* be linked first; crtn.o must be linked last. Because these
* are wildcards, it doesn't matter if the user does not
* actually link against crti.o and crtn.o; the linker won't
* look for a file to match a wildcard. The wildcard also
* means that it doesn't matter which directory crti.o and
* crtn.o are in.
*/
PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
etext = ALIGN( 0x10 ) ; /*
} * C++ constructors/destructors
.data 0x010000 : *
{ * gcc uses crtbegin.o to find the start of the constructors
data_start = . ; * and destructors so we make sure it is first. Because this
*(.data) * is a wildcard, it doesn't matter if the user does not
*(.gnu.linkonce.d.*) * actually link against crtbegin.o; the linker won't look for
*(.gcc_except_table) * a file to match a wildcard. The wildcard also means that
edata = ALIGN( 0x10 ) ; * it doesn't matter which directory crtbegin.o is in. The
} * constructor and destructor list are terminated in
.bss ADDR( .data ) + SIZEOF( .data ): * crtend.o. The same comments apply to it.
{ */
bss_start = . ; . = ALIGN (16);
*(.bss) *crtbegin.o(.ctors)
*(COMMON) *(.ctors)
end = . ; *crtend.o(.ctors)
_end = . ; *crtbegin.o(.dtors)
} *(.dtors)
*crtend.o(.dtors)
/*
* Exception frame info
*/
. = ALIGN (16);
*(.eh_frame)
/*
* Read-only data
*/
. = ALIGN (16);
_rodata_start = . ;
*(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : {
PROVIDE (_copy_start = .);
*(.data)
*(.gnu.linkonce.d*)
*(.gcc_except_table)
. = ALIGN (16);
PROVIDE (_edata = .);
PROVIDE (_copy_end = .);
} >ram
.bss : {
PROVIDE (_bss_start = .);
PROVIDE (_clear_start = .);
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
} }

6
c/src/lib/libbsp/m68k/gen68340/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

145
c/src/lib/libbsp/m68k/gen68340/startup/linkcmds
View File

@@ -24,9 +24,6 @@ OUTPUT_FORMAT(coff-m68k)
/* /*
* Declare some sizes. * Declare some sizes.
* XXX: The assignment of ". += XyzSize;" fails in older gld's if the
* number used there is not constant. If this happens to you, edit
* the lines marked XXX below to use a constant value.
*/ */
RamSize = DEFINED(RamSize) ? RamSize : 4M; RamSize = DEFINED(RamSize) ? RamSize : 4M;
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000; HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
@@ -79,37 +76,106 @@ SECTIONS {
* Text, data and bss segments * Text, data and bss segments
*/ */
.text : { .text : {
CREATE_OBJECT_SYMBOLS
*(.text) *(.text)
. = ALIGN (16);
/* /*
* C++ constructors * C++ constructors/destructors
*/ */
__CTOR_LIST__ = .; *(.gnu.linkonce.t.*)
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
/*
* Initialization and finalization code.
*
* Various files can provide initialization and finalization
* functions. crtbegin.o and crtend.o are two instances. The
* body of these functions are in .init and .fini sections. We
* accumulate the bodies here, and prepend function prologues
* from crti.o and function epilogues from crtn.o. crti.o must
* be linked first; crtn.o must be linked last. Because these
* are wildcards, it doesn't matter if the user does not
* actually link against crti.o and crtn.o; the linker won't
* look for a file to match a wildcard. The wildcard also
* means that it doesn't matter which directory crti.o and
* crtn.o are in.
*/
PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
/*
* C++ constructors/destructors
*
* gcc uses crtbegin.o to find the start of the constructors
* and destructors 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. The
* constructor and destructor list are terminated in
* crtend.o. The same comments apply to it.
*/
. = ALIGN (16);
*crtbegin.o(.ctors)
*(.ctors) *(.ctors)
LONG(0) *crtend.o(.ctors)
__CTOR_END__ = .; *crtbegin.o(.dtors)
__DTOR_LIST__ = .;
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
*(.dtors) *(.dtors)
LONG(0) *crtend.o(.dtors)
__DTOR_END__ = .;
etext = .; /*
_etext = .; * Exception frame info
} >rom */
.eh_fram : {
. = ALIGN (16); . = ALIGN (16);
*(.eh_fram) *(.eh_frame)
} >ram
.gcc_exc : { /*
* Read-only data
*/
. = ALIGN (16); . = ALIGN (16);
*(.gcc_exc) _rodata_start = . ;
} >ram *(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : {
PROVIDE (_copy_start = .);
*(.data)
*(.gnu.linkonce.d*)
*(.gcc_except_table)
. = ALIGN (16);
PROVIDE (_edata = .);
PROVIDE (_copy_end = .);
} >ram
.bss : {
M68Kvec = .;
_M68Kvec = .;
. += (256 * 4);
PROVIDE (_bss_start = .);
PROVIDE (_clear_start = .);
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
/* /*
* On-chip memory/peripherals * On-chip memory/peripherals
@@ -121,35 +187,4 @@ SECTIONS {
. += (8 * 1024); . += (8 * 1024);
} >ram } >ram
.data : {
copy_start = .;
*(.data)
. = ALIGN (16);
_edata = .;
copy_end = .;
} >ram
.bss : {
M68Kvec = .;
_M68Kvec = .;
. += (256 * 4);
clear_start = .;
*(.bss)
*(COMMON)
. = ALIGN (16);
_end = .;
_HeapStart = .;
__HeapStart = .;
. += HeapSize; /* XXX -- Old gld can't handle this */
. += StackSize; /* XXX -- Old gld can't handle this */
/* . += 0x10000; */ /* HeapSize for old gld */
/* . += 0x1000; */ /* StackSize for old gld */
. = ALIGN (16);
stack_init = .;
clear_end = .;
_WorkspaceBase = .;
__WorkspaceBase = .;
} >ram
} }

6
c/src/lib/libbsp/m68k/gen68360/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

107
c/src/lib/libbsp/m68k/gen68360/startup/linkcmds
View File

@@ -13,9 +13,6 @@
/* /*
* Declare some sizes. * Declare some sizes.
* XXX: The assignment of ". += XyzSize;" fails in older gld's if the
* number used there is not constant. If this happens to you, edit
* the lines marked XXX below to use a constant value.
*/ */
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000; HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000; StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
@@ -38,7 +35,6 @@ SECTIONS {
*/ */
rom : { rom : {
_RomBase = .; _RomBase = .;
__RomBase = .;
} >rom } >rom
/* /*
@@ -46,55 +42,87 @@ SECTIONS {
*/ */
ram : { ram : {
_RamBase = .; _RamBase = .;
__RamBase = .;
} >ram } >ram
/* /*
* Text, data and bss segments * Text, data and bss segments
*/ */
.text : { .text : {
CREATE_OBJECT_SYMBOLS
*(.text) *(.text)
. = ALIGN (16);
*(.gnu.linkonce.t.*)
*(.descriptors)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
*(.eh_fram)
. = ALIGN (16);
*(.gcc_exc)
/* /*
* C++ constructors * C++ constructors/destructors
*/ */
__CTOR_LIST__ = .; *(.gnu.linkonce.t.*)
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
*(.ctors)
LONG(0)
__CTOR_END__ = .;
__DTOR_LIST__ = .;
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
*(.dtors)
LONG(0)
__DTOR_END__ = .;
/*
* Initialization and finalization code.
*
* Various files can provide initialization and finalization
* functions. crtbegin.o and crtend.o are two instances. The
* body of these functions are in .init and .fini sections. We
* accumulate the bodies here, and prepend function prologues
* from crti.o and function epilogues from crtn.o. crti.o must
* be linked first; crtn.o must be linked last. Because these
* are wildcards, it doesn't matter if the user does not
* actually link against crti.o and crtn.o; the linker won't
* look for a file to match a wildcard. The wildcard also
* means that it doesn't matter which directory crti.o and
* crtn.o are in.
*/
PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
/*
* C++ constructors/destructors
*
* gcc uses crtbegin.o to find the start of the constructors
* and destructors 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. The
* constructor and destructor list are terminated in
* crtend.o. The same comments apply to it.
*/
. = ALIGN (16);
*crtbegin.o(.ctors)
*(.ctors)
*crtend.o(.ctors)
*crtbegin.o(.dtors)
*(.dtors)
*crtend.o(.dtors)
/*
* Exception frame info
*/
. = ALIGN (16);
*(.eh_frame)
/*
* Read-only data
*/
. = ALIGN (16);
_rodata_start = . ; _rodata_start = . ;
*(.rodata) *(.rodata)
*(.gnu.linkonce.r*) *(.gnu.linkonce.r*)
. = ALIGN (16); . = ALIGN (16);
etext = .; PROVIDE (etext = .);
_etext = .; } >ram
} >ram
.data : { .data : {
copy_start = .; copy_start = .;
*(.data) *(.data)
*(.gnu.linkonce.d*) *(.gnu.linkonce.d*)
*(.gcc_except_table) *(.gcc_except_table)
. = ALIGN (16); . = ALIGN (16);
_edata = .; PROVIDE (_edata = .);
copy_end = .; copy_end = .;
} >ram } >ram
.bss : { .bss : {
@@ -105,20 +133,19 @@ SECTIONS {
*(.bss) *(.bss)
*(COMMON) *(COMMON)
. = ALIGN (16); . = ALIGN (16);
_end = .; PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
_HeapStart = .;
__HeapStart = .;
. += HeapSize; /* XXX -- Old gld can't handle this */
. += StackSize; /* XXX -- Old gld can't handle this */
/* . += 0x10000; */ /* HeapSize for old gld */
/* . += 0x1000; */ /* StackSize for old gld */
. = ALIGN (16); . = ALIGN (16);
stack_init = .; PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .; clear_end = .;
_WorkspaceBase = .; _WorkspaceBase = .;
__WorkspaceBase = .;
} >ram } >ram
/* /*

6
c/src/lib/libbsp/m68k/idp/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

154
c/src/lib/libbsp/m68k/idp/startup/linkcmds
View File

@@ -12,60 +12,122 @@
* both the rom68k and the mon68k monitors. * both the rom68k and the mon68k monitors.
*/ */
StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
MEMORY MEMORY
{ {
ram : org = 0x10000, l = 2M ram : org = 0x10000, l = 2M
} }
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
SECTIONS SECTIONS
{ {
.text 0x10000: ram : {
{ . = .;
text_start = . ; } >ram
_text_start = . ;
*(.text)
. = ALIGN (16);
*(.eh_fram) /*
. = ALIGN (16); * Text, data and bss segments
*/
.text : {
*(.text)
. = ALIGN (16); /*
*(.gcc_exc) * C++ constructors/destructors
*/
*(.gnu.linkonce.t.*)
/* /*
* C++ constructors * Initialization and finalization code.
*/ *
__CTOR_LIST__ = .; * Various files can provide initialization and finalization
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2) * functions. crtbegin.o and crtend.o are two instances. The
*(.ctors) * body of these functions are in .init and .fini sections. We
LONG(0) * accumulate the bodies here, and prepend function prologues
__CTOR_END__ = .; * from crti.o and function epilogues from crtn.o. crti.o must
__DTOR_LIST__ = .; * be linked first; crtn.o must be linked last. Because these
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) * are wildcards, it doesn't matter if the user does not
*(.dtors) * actually link against crti.o and crtn.o; the linker won't
LONG(0) * look for a file to match a wildcard. The wildcard also
__DTOR_END__ = .; * means that it doesn't matter which directory crti.o and
etext = ALIGN( 0x10 ) ; * crtn.o are in.
_etext = .; */
} PROVIDE (_init = .);
.data : { *crti.o(.init)
data_start = . ; *(.init)
_data_start = .; *crtn.o(.init)
*(.data) PROVIDE (_fini = .);
edata = ALIGN( 0x10 ) ; *crti.o(.fini)
_edata = .; *(.fini)
} *crtn.o(.fini)
.bss : {
bss_start = . ; /*
_bss_start = . ; * C++ constructors/destructors
*(.bss) *
*(COMMON) * gcc uses crtbegin.o to find the start of the constructors
. += StackSize; /* XXX -- Old gld can't handle this */ * and destructors so we make sure it is first. Because this
. = ALIGN (16); * is a wildcard, it doesn't matter if the user does not
stack_init = .; * actually link against crtbegin.o; the linker won't look for
end = . ; * a file to match a wildcard. The wildcard also means that
_end = . ; * it doesn't matter which directory crtbegin.o is in. The
} * constructor and destructor list are terminated in
* crtend.o. The same comments apply to it.
*/
. = ALIGN (16);
*crtbegin.o(.ctors)
*(.ctors)
*crtend.o(.ctors)
*crtbegin.o(.dtors)
*(.dtors)
*crtend.o(.dtors)
/*
* Exception frame info
*/
. = ALIGN (16);
*(.eh_frame)
/*
* Read-only data
*/
. = ALIGN (16);
_rodata_start = . ;
*(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : {
PROVIDE (_copy_start = .);
*(.data)
*(.gnu.linkonce.d*)
*(.gcc_except_table)
. = ALIGN (16);
PROVIDE (_edata = .);
PROVIDE (_copy_end = .);
} >ram
.bss : {
PROVIDE (_bss_start = .);
PROVIDE (_clear_start = .);
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
} }

6
c/src/lib/libbsp/m68k/mvme136/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

152
c/src/lib/libbsp/m68k/mvme136/startup/linkcmds
View File

@@ -12,56 +12,122 @@
* $Id$ * $Id$
*/ */
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000; StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
MEMORY MEMORY
{ {
ram : org = 0x3000, l = 1M ram : org = 0x0, l = 1M
} }
SECTIONS SECTIONS
{ {
.text 0x3000 : ram : {
{ . = 0x3000;
text_start = . ; } >ram
_text_start = . ;
*(.text)
. = ALIGN (16);
*(.eh_fram) /*
. = ALIGN (16); * Text, data and bss segments
*/
.text : {
*(.text)
/* /*
* C++ constructors * C++ constructors/destructors
*/ *
__CTOR_LIST__ = .; * Various files can provide initialization and finalization
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2) * functions. crtbegin.o and crtend.o are two instances. The
*(.ctors) * body of these functions are in .init and .fini sections. We
LONG(0) * accumulate the bodies here, and prepend function prologues
__CTOR_END__ = .; * from crti.o and function epilogues from crtn.o. crti.o must
__DTOR_LIST__ = .; * be linked first; crtn.o must be linked last. Because these
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) * are wildcards, it doesn't matter if the user does not
*(.dtors) * actually link against crti.o and crtn.o; the linker won't
LONG(0) * look for a file to match a wildcard. The wildcard also
__DTOR_END__ = .; * means that it doesn't matter which directory crti.o and
etext = ALIGN( 0x10 ) ; * crtn.o are in.
_etext = .; */
} *(.gnu.linkonce.t.*)
/*
* Initialization and finalization code.
*
* gcc uses crtbegin.o to find the start of the constructors
* and destructors 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. The
* constructor and destructor list are terminated in
* crtend.o. The same comments apply to it.
*/
PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
/*
* C++ constructors/destructors
*/
. = ALIGN (16);
*crtbegin.o(.ctors)
*(.ctors)
*crtend.o(.ctors)
*crtbegin.o(.dtors)
*(.dtors)
*crtend.o(.dtors)
/*
* Exception frame info
*/
. = ALIGN (16);
*(.eh_frame)
/*
* Read-only data
*/
. = ALIGN (16);
_rodata_start = . ;
*(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : { .data : {
data_start = . ; PROVIDE (_copy_start = .);
_data_start = .; *(.data)
*(.data) *(.gnu.linkonce.d*)
edata = ALIGN( 0x10 ) ; *(.gcc_except_table)
_edata = .;
}
.bss : {
bss_start = . ;
_bss_start = . ;
*(.bss)
*(COMMON)
. += StackSize; /* XXX -- Old gld can't handle this */
. = ALIGN (16); . = ALIGN (16);
stack_init = .; PROVIDE (_edata = .);
end = . ; PROVIDE (_copy_end = .);
_end = . ; } >ram
} .bss : {
PROVIDE (_bss_start = .);
PROVIDE (_clear_start = .);
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
} }

6
c/src/lib/libbsp/m68k/mvme147/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

151
c/src/lib/libbsp/m68k/mvme147/startup/linkcmds
View File

@@ -16,57 +16,122 @@
* $Id$ * $Id$
*/ */
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000; StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
MEMORY MEMORY
{ {
ram : org = 0x5000, l = 0x3fafff ram : org = 0x0, l = 0x400000
} }
SECTIONS SECTIONS
{ {
.text 0x5000 : ram : {
{ . = 0x5000;
text_start = . ; } >ram
_text_start = . ;
*(.text)
. = ALIGN (16);
*(.eh_fram) /*
. = ALIGN (16); * Text, data and bss segments
*/
.text : {
*(.text)
/* /*
* C++ constructors * C++ constructors/destructors
*/ */
__CTOR_LIST__ = .; *(.gnu.linkonce.t.*)
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
*(.ctors) /*
LONG(0) * Initialization and finalization code.
__CTOR_END__ = .; *
__DTOR_LIST__ = .; * Various files can provide initialization and finalization
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) * functions. crtbegin.o and crtend.o are two instances. The
*(.dtors) * body of these functions are in .init and .fini sections. We
LONG(0) * accumulate the bodies here, and prepend function prologues
__DTOR_END__ = .; * from crti.o and function epilogues from crtn.o. crti.o must
etext = ALIGN( 0x10 ) ; * be linked first; crtn.o must be linked last. Because these
_etext = .; * are wildcards, it doesn't matter if the user does not
} * actually link against crti.o and crtn.o; the linker won't
* look for a file to match a wildcard. The wildcard also
* means that it doesn't matter which directory crti.o and
* crtn.o are in.
*/
PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
/*
* C++ constructors/destructors
*
* gcc uses crtbegin.o to find the start of the constructors
* and destructors 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. The
* constructor and destructor list are terminated in
* crtend.o. The same comments apply to it.
*/
. = ALIGN (16);
*crtbegin.o(.ctors)
*(.ctors)
*crtend.o(.ctors)
*crtbegin.o(.dtors)
*(.dtors)
*crtend.o(.dtors)
/*
* Exception frame info
*/
. = ALIGN (16);
*(.eh_frame)
/*
* Read-only data
*/
. = ALIGN (16);
_rodata_start = . ;
*(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : { .data : {
data_start = . ; PROVIDE (_copy_start = .);
_data_start = .; *(.data)
*(.data) *(.gnu.linkonce.d*)
edata = ALIGN( 0x10 ) ; *(.gcc_except_table)
_edata = .; . = ALIGN (16);
} PROVIDE (_edata = .);
PROVIDE (_copy_end = .);
} >ram
.bss : { .bss : {
bss_start = . ; PROVIDE (_bss_start = .);
_bss_start = . ; PROVIDE (_clear_start = .);
*(.bss) *(.bss)
*(COMMON) *(COMMON)
. += StackSize; /* XXX -- Old gld can't handle this */ . = ALIGN (16);
. = ALIGN (16); PROVIDE (end = .);
stack_init = .;
end = . ; . += StackSize;
_end = . ; PROVIDE (_stack_init = .);
}
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
} }

6
c/src/lib/libbsp/m68k/mvme147s/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

164
c/src/lib/libbsp/m68k/mvme147s/startup/linkcmds
View File

@@ -16,72 +16,122 @@
* $Id$ * $Id$
*/ */
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000; StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
MEMORY MEMORY
{ {
ram : org = 0x7000, l = 0x3d8fff ram : org = 0x0, l = 0x400000
} }
SECTIONS SECTIONS
{ {
.text 0x7000 : ram : {
{ . = 0x7000;
text_start = . ; } >ram
_text_start = . ;
*(.text)
. = ALIGN (16);
*(.gnu.linkonce.t.*) /*
*(.descriptors) * Text, data and bss segments
/* .gnu.warning sections are handled specially by elf32.em. */ */
*(.gnu.warning) .text : {
*(.text)
*(.eh_fram) /*
. = ALIGN (16); * C++ constructors/destructors
*/
*(.gnu.linkonce.t.*)
/* /*
* C++ constructors * Initialization and finalization code.
*/ *
__CTOR_LIST__ = .; * Various files can provide initialization and finalization
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2) * functions. crtbegin.o and crtend.o are two instances. The
*(.ctors) * body of these functions are in .init and .fini sections. We
LONG(0) * accumulate the bodies here, and prepend function prologues
__CTOR_END__ = .; * from crti.o and function epilogues from crtn.o. crti.o must
__DTOR_LIST__ = .; * be linked first; crtn.o must be linked last. Because these
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) * are wildcards, it doesn't matter if the user does not
*(.dtors) * actually link against crti.o and crtn.o; the linker won't
LONG(0) * look for a file to match a wildcard. The wildcard also
__DTOR_END__ = .; * means that it doesn't matter which directory crti.o and
* crtn.o are in.
*/
PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
_rodata_start = . ; /*
*(.rodata) * C++ constructors/destructors
*(.gnu.linkonce.r*) *
_erodata = ALIGN( 0x10 ) ; * gcc uses crtbegin.o to find the start of the constructors
* and destructors 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. The
* constructor and destructor list are terminated in
* crtend.o. The same comments apply to it.
*/
. = ALIGN (16);
*crtbegin.o(.ctors)
*(.ctors)
*crtend.o(.ctors)
*crtbegin.o(.dtors)
*(.dtors)
*crtend.o(.dtors)
etext = ALIGN( 0x10 ) ; /*
_etext = .; * Exception frame info
} */
.data ADDR( .text ) + SIZEOF( .text ): . = ALIGN (16);
{ *(.eh_frame)
data_start = . ;
_data_start = .; /*
*(.data) * Read-only data
*(.gnu.linkonce.d*) */
*(.gcc_except_table) . = ALIGN (16);
edata = ALIGN( 0x10 ) ; _rodata_start = . ;
_edata = .; *(.rodata)
} *(.gnu.linkonce.r*)
.bss ADDR( .data ) + SIZEOF( .data ):
{ . = ALIGN (16);
bss_start = . ; PROVIDE (_etext = .);
_bss_start = . ; } >ram
*(.bss) .data : {
*(COMMON) PROVIDE (_copy_start = .);
. += StackSize; /* XXX -- Old gld can't handle this */ *(.data)
. = ALIGN (16); *(.gnu.linkonce.d*)
stack_init = .; *(.gcc_except_table)
end = . ; . = ALIGN (16);
_end = . ; PROVIDE (_edata = .);
} PROVIDE (_copy_end = .);
} >ram
.bss : {
PROVIDE (_bss_start = .);
PROVIDE (_clear_start = .);
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
} }

6
c/src/lib/libbsp/m68k/mvme162/bsp_specs
View File

@@ -19,8 +19,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

144
c/src/lib/libbsp/m68k/mvme162/startup/linkcmds
View File

@@ -19,52 +19,122 @@
* $Id$ * $Id$
*/ */
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000; StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
MEMORY MEMORY
{ {
ram : org = 0x100000, l = 1M ram : org = 0x100000, l = 1M
} }
SECTIONS SECTIONS
{ {
.text 0x100000 : ram : {
{ . = .;
text_start = . ; } >ram
*(.text)
. = ALIGN (16);
*(.eh_fram) /*
. = ALIGN (16); * Text, data and bss segments
*/
.text : {
*(.text)
/* /*
* C++ constructors * C++ constructors/destructors
*/ */
__CTOR_LIST__ = .; *(.gnu.linkonce.t.*)
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
*(.ctors) /*
LONG(0) * Initialization and finalization code.
__CTOR_END__ = .; *
__DTOR_LIST__ = .; * Various files can provide initialization and finalization
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) * functions. crtbegin.o and crtend.o are two instances. The
*(.dtors) * body of these functions are in .init and .fini sections. We
LONG(0) * accumulate the bodies here, and prepend function prologues
__DTOR_END__ = .; * from crti.o and function epilogues from crtn.o. crti.o must
etext = ALIGN( 0x10 ) ; * be linked first; crtn.o must be linked last. Because these
} * are wildcards, it doesn't matter if the user does not
* actually link against crti.o and crtn.o; the linker won't
* look for a file to match a wildcard. The wildcard also
* means that it doesn't matter which directory crti.o and
* crtn.o are in.
*/
PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
/*
* C++ constructors/destructors
*
* gcc uses crtbegin.o to find the start of the constructors
* and destructors 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. The
* constructor and destructor list are terminated in
* crtend.o. The same comments apply to it.
*/
. = ALIGN (16);
*crtbegin.o(.ctors)
*(.ctors)
*crtend.o(.ctors)
*crtbegin.o(.dtors)
*(.dtors)
*crtend.o(.dtors)
/*
* Exception frame info
*/
. = ALIGN (16);
*(.eh_frame)
/*
* Read-only data
*/
. = ALIGN (16);
_rodata_start = . ;
*(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : { .data : {
data_start = . ; PROVIDE (_copy_start = .);
*(.data) *(.data)
edata = ALIGN( 0x10 ) ; *(.gnu.linkonce.d*)
} *(.gcc_except_table)
. = ALIGN (16);
PROVIDE (_edata = .);
PROVIDE (_copy_end = .);
} >ram
.bss : { .bss : {
bss_start = . ; PROVIDE (_bss_start = .);
*(.bss) PROVIDE (_clear_start = .);
*(COMMON) *(.bss)
. += StackSize; /* XXX -- Old gld can't handle this */ *(COMMON)
. = ALIGN (16); . = ALIGN (16);
stack_init = .; PROVIDE (end = .);
end = . ;
_end = . ; . += StackSize;
} PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
} }

6
c/src/lib/libbsp/m68k/mvme167/bsp_specs
View File

@@ -20,8 +20,12 @@ elflinkcmds%s}}}
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s} %{qelf crti.o%s crtbegin.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

262
c/src/lib/libbsp/m68k/mvme167/startup/linkcmds
View File

@@ -29,9 +29,6 @@ RAM_END = RAM_START + RAM_SIZE;
/* /*
* Declare some sizes. * Declare some sizes.
* XXX: The assignment of ". += XyzSize;" fails in older gld's if the
* number used there is not constant. If this happens to you, edit
* the lines marked XXX below to use a constant value.
*/ */
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000; HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000; StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
@@ -49,175 +46,108 @@ MEMORY
SECTIONS SECTIONS
{ {
/* ram : {
* We want the entry point to be the first thing in memory. . = .;
* Merge all read-only data into the .text section. } >ram
*/
.text 0x00800000 :
{
text_start = . ;
*(.text)
*(.text.*)
*(.stub)
/* C++ constructors/destructors */ /*
*(.gnu.linkonce.t*) * Text, data and bss segments
*/
/* Initialization and finalization code. .text : {
* *(.text)
* Various files can provide initialization and finalization functions.
* crtbegin.o and crtend.o are two instances. The body of these functions
* are in .init and .fini sections. We accumulate the bodies here, and
* prepend function prologues from crti.o and function epilogues from
* crtn.o. crti.o must be linked first; crtn.o must be linked last.
* Because these are wildcards, it doesn't matter if the user does not
* actually link against crti.o and crtn.o; the linker won't look for a
* file to match a wildcard. The wildcard also means that it doesn't
* matter which directory crti.o and crtn.o are in.
*/
PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.init)
. = ALIGN (16);
/* C++ constructors and destructors for static objects.
*
* gcc uses crtbegin.o to find the start of the constructors and
* destructors 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. The constructor and destructor list are terminated in crtend.o.
* The same comments apply to it.
*/
PROVIDE (__CTOR_LIST__ = .);
*crtbegin.o(.ctors)
*(.ctors)
*crtend.o(.ctors)
PROVIDE (__CTOR_END__ = .);
PROVIDE (__DTOR_LIST__ = .); /*
*crtbegin.o(.dtors) * C++ constructors/destructors
*(.dtors) */
*crtend.o(.dtors) *(.gnu.linkonce.t.*)
PROVIDE (__DTOR_END__ = .);
. = ALIGN (16);
/* Exception frame info */
*(.eh_frame)
. = ALIGN (16);
/* Do we have any of these with egcs-1.x and higher? */ /*
*(.gcc_exc) * Initialization and finalization code.
*
. = ALIGN (16); * Various files can provide initialization and finalization
* functions. crtbegin.o and crtend.o are two instances. The
_rodata_start = . ; * body of these functions are in .init and .fini sections. We
*(.rodata) * accumulate the bodies here, and prepend function prologues
*(.rodata.*) * from crti.o and function epilogues from crtn.o. crti.o must
*(.gnu.linkonce.r*) * be linked first; crtn.o must be linked last. Because these
*(.rodata1) * are wildcards, it doesn't matter if the user does not
_erodata = .; * actually link against crti.o and crtn.o; the linker won't
* look for a file to match a wildcard. The wildcard also
* means that it doesn't matter which directory crti.o and
* crtn.o are in.
*/
PROVIDE (_init = .);
*crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
_etext = .; /*
PROVIDE (etext = .); * C++ constructors/destructors
*
} >ram =0x4e75 * gcc uses crtbegin.o to find the start of the constructors
* and destructors so we make sure it is first. Because this
. = ALIGN (16); * is a wildcard, it doesn't matter if the user does not
* actually link against crtbegin.o; the linker won't look for
.data : * a file to match a wildcard. The wildcard also means that
{ * it doesn't matter which directory crtbegin.o is in. The
data_start = .; * constructor and destructor list are terminated in
* crtend.o. The same comments apply to it.
*(.data) */
*(.data.*) . = ALIGN (16);
*(.data1) *crtbegin.o(.ctors)
*(.sdata) *(.ctors)
*(.gnu.linkonce.d*) *crtend.o(.ctors)
*(.gcc_except_table) *crtbegin.o(.dtors)
*(.dtors)
. = ALIGN (16); *crtend.o(.dtors)
_edata = .;
PROVIDE (edata = .);
} >ram
.bss : /*
{ * Exception frame info
bss_start = .; */
*(.dynbss) . = ALIGN (16);
*(.bss) *(.eh_frame)
*(COMMON)
*(.sbss)
*(.scommon)
. = ALIGN (16);
_end = .;
PROVIDE (end = .);
} >ram
_HeapStart = .; /*
. += HeapSize; /* XXX -- Old gld can't handle this */ * Read-only data
_HeapEnd = .; */
_StackStart = .; . = ALIGN (16);
. += StackSize; /* XXX -- Old gld can't handle this */ _rodata_start = . ;
/* . += 0x10000; */ /* HeapSize for old gld */ *(.rodata)
/* . += 0x1000; */ /* StackSize for old gld */ *(.gnu.linkonce.r*)
. = ALIGN (16);
_StackEnd = .;
stack_init = .;
clear_end = .;
_WorkspaceBase = .; . = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : {
PROVIDE (_copy_start = .);
*(.data)
*(.gnu.linkonce.d*)
*(.gcc_except_table)
. = ALIGN (16);
PROVIDE (_edata = .);
PROVIDE (_copy_end = .);
} >ram
.bss : {
PROVIDE (_bss_start = .);
PROVIDE (_clear_start = .);
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
/* Stabs debugging sections. */ . += StackSize;
.stab 0 : { *(.stab) } PROVIDE (_stack_init = .);
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) } . = ALIGN (16);
.stab.exclstr 0 : { *(.stab.exclstr) } PROVIDE (_HeapStart = .);
.stab.index 0 : { *(.stab.index) } . += HeapSize;
.stab.indexstr 0 : { *(.stab.indexstr) } PROVIDE (_HeapEnd = .);
.comment 0 : { *(.comment) } PROVIDE (_clear_end = .);
/* DWARF debug sections. PROVIDE (_WorkspaceBase = .);
Symbols in the DWARF debugging sections are relative to the beginning } >ram
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) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.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) }
/* These must appear regardless of . */
} }

6
c/src/lib/libbsp/m68k/ods68302/bsp_specs
View File

@@ -16,8 +16,12 @@
*startfile: *startfile:
%{!qrtems: %(old_startfile)} %{qrtems: \ %{!qrtems: %(old_startfile)} %{qrtems: \
%{!qrtems_debug: start.o%s} \ %{!qrtems_debug: start.o%s} \
%{qrtems_debug: start_g.o%s}} %{qrtems_debug: start_g.o%s} \
crti.o%s crtbegin.o%s}
*link: *link:
%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start} %{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
*endfile:
%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}

163
c/src/lib/libbsp/m68k/ods68302/startup/linkcmds
View File

@@ -5,52 +5,133 @@
* *
*/ */
/*
* Declare some sizes.
*/
HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
/*
* Declare on-board memory.
*/
MEMORY {
ram : ORIGIN = 0x00000000, LENGTH = 1M
}
SECTIONS SECTIONS
{ {
.vtable 0 : ram : {
{ . = .;
vtable_start = .; } >ram
*(.vtable)
evtable = .;
}
.text . : .vtable :
{ {
text_start = .; vtable_start = .;
*(.text) *(.vtable)
. = ALIGN (16); evtable = .;
} >ram
*(.eh_fram)
. = ALIGN (16);
etext = .; /*
. = ALIGN(4); * Text, data and bss segments
__CTOR_LIST__ = .; */
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2) .text : {
*(.ctors) *(.text)
LONG(0)
__CTOR_END__ = .; /*
. = ALIGN(4); * C++ constructors/destructors
__DTOR_LIST__ = .; */
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2) *(.gnu.linkonce.t.*)
*(.dtors)
LONG(0) /*
__DTOR_END__ = .; * Initialization and finalization code.
} *
* Various files can provide initialization and finalization
.data : { * functions. crtbegin.o and crtend.o are two instances. The
data_start = .; * body of these functions are in .init and .fini sections. We
*(.data) * accumulate the bodies here, and prepend function prologues
*(.rodata) * from crti.o and function epilogues from crtn.o. crti.o must
edata = .; * be linked first; crtn.o must be linked last. Because these
} * are wildcards, it doesn't matter if the user does not
.bss : { * actually link against crti.o and crtn.o; the linker won't
bss_start = .; * look for a file to match a wildcard. The wildcard also
*(.bss) * means that it doesn't matter which directory crti.o and
*(COMMON) * crtn.o are in.
end = . ; */
_end = . ; PROVIDE (_init = .);
} *crti.o(.init)
*(.init)
*crtn.o(.init)
PROVIDE (_fini = .);
*crti.o(.fini)
*(.fini)
*crtn.o(.fini)
/*
* C++ constructors/destructors
*
* gcc uses crtbegin.o to find the start of the constructors
* and destructors 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. The
* constructor and destructor list are terminated in
* crtend.o. The same comments apply to it.
*/
. = ALIGN (16);
*crtbegin.o(.ctors)
*(.ctors)
*crtend.o(.ctors)
*crtbegin.o(.dtors)
*(.dtors)
*crtend.o(.dtors)
/*
* Exception frame info
*/
. = ALIGN (16);
*(.eh_frame)
/*
* Read-only data
*/
. = ALIGN (16);
_rodata_start = . ;
*(.rodata)
*(.gnu.linkonce.r*)
. = ALIGN (16);
PROVIDE (_etext = .);
} >ram
.data : {
PROVIDE (_copy_start = .);
*(.data)
*(.gnu.linkonce.d*)
*(.gcc_except_table)
. = ALIGN (16);
PROVIDE (_edata = .);
PROVIDE (_copy_end = .);
} >ram
.bss : {
PROVIDE (_bss_start = .);
PROVIDE (_clear_start = .);
*(.bss)
*(COMMON)
. = ALIGN (16);
PROVIDE (end = .);
. += StackSize;
PROVIDE (_stack_init = .);
. = ALIGN (16);
PROVIDE (_HeapStart = .);
. += HeapSize;
PROVIDE (_HeapEnd = .);
clear_end = .;
PROVIDE (_WorkspaceBase = .);
} >ram
} }
m302 = MC68302_BASE; m302 = MC68302_BASE;