Changeset b2b4835 in rtems for c/src/lib/libbsp/m68k


Ignore:
Timestamp:
Jan 12, 2000, 4:38:57 PM (21 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
c1d2cc9
Parents:
69537ca9
Message:

Eric Norum <eric@…> submitted linker script and bsp_specs
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.

Location:
c/src/lib/libbsp/m68k
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/m68k/dmv152/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/dmv152/startup/linkcmds

    r69537ca9 rb2b4835  
    1313 */
    1414
     15/*
     16 * Declare some sizes.
     17 */
     18HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
    1519StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
    1620
    1721MEMORY
    18         {
    19         ram : org = 0x12800, l = 1M
    20         }
     22{
     23        ram : org = 0x0, l = 1M
     24}
    2125
    2226SECTIONS
    2327{
    24         .text 0x12800 :
    25         {
    26         text_start = . ;
    27         _text_start = . ;
    28         *(.text)
    29         . = ALIGN (16);
     28        ram : {
     29                . = 0x12800;
     30        } >ram
    3031
    31         *(.eh_fram)
    32         . = ALIGN (16);
     32        /*
     33         * Text, data and bss segments
     34         */
     35        .text : {
     36                *(.text)
    3337
    34         . = ALIGN (16);
    35         *(.gcc_exc)
     38                /*
     39                 * C++ constructors/destructors
     40                 */
     41                *(.gnu.linkonce.t.*)
    3642
    37         /*
    38          * C++ constructors
    39          */
    40         __CTOR_LIST__ = .;
    41         LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    42         *(.ctors)
    43         LONG(0)
    44         __CTOR_END__ = .;
    45         __DTOR_LIST__ = .;
    46         LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    47         *(.dtors)
    48         LONG(0)
    49         __DTOR_END__ = .;
    50         etext = ALIGN( 0x10 ) ;
    51         _etext = .;
    52         }
     43                /*
     44                 * Initialization and finalization code.
     45                 *
     46                 * Various files can provide initialization and finalization
     47                 * functions.  crtbegin.o and crtend.o are two instances. The
     48                 * body of these functions are in .init and .fini sections. We
     49                 * accumulate the bodies here, and prepend function prologues
     50                 * from crti.o and function epilogues from crtn.o. crti.o must
     51                 * be linked first; crtn.o must be linked last.  Because these
     52                 * are wildcards, it doesn't matter if the user does not
     53                 * actually link against crti.o and crtn.o; the linker won't
     54                 * look for a file to match a wildcard.  The wildcard also
     55                 * means that it doesn't matter which directory crti.o and
     56                 * crtn.o are in.
     57                 */
     58                PROVIDE (_init = .);
     59                *crti.o(.init)
     60                *(.init)
     61                *crtn.o(.init)
     62                PROVIDE (_fini = .);
     63                *crti.o(.fini)
     64                *(.fini)
     65                *crtn.o(.fini)
    5366
     67                /*
     68                 * C++ constructors/destructors
     69                 *
     70                 * gcc uses crtbegin.o to find the start of the constructors
     71                 * and destructors so we make sure it is first.  Because this
     72                 * is a wildcard, it doesn't matter if the user does not
     73                 * actually link against crtbegin.o; the linker won't look for
     74                 * a file to match a wildcard.  The wildcard also means that
     75                 * it doesn't matter which directory crtbegin.o is in. The
     76                 * constructor and destructor list are terminated in
     77                 * crtend.o.  The same comments apply to it.
     78                 */
     79                . = ALIGN (16);
     80                *crtbegin.o(.ctors)
     81                *(.ctors)
     82                *crtend.o(.ctors)
     83                *crtbegin.o(.dtors)
     84                *(.dtors)
     85                *crtend.o(.dtors)
    5486
     87                /*
     88                 * Exception frame info
     89                 */
     90                . = ALIGN (16);
     91                *(.eh_frame)
     92
     93                /*
     94                 * Read-only data
     95                 */
     96                . = ALIGN (16);
     97                _rodata_start = . ;
     98                *(.rodata)
     99                *(.gnu.linkonce.r*)
     100
     101                 . = ALIGN (16);
     102                PROVIDE (etext = .);
     103        } >ram
    55104        .data : {
    56                 data_start = . ;
    57                 _data_start = . ;
    58                 *(.data)
    59                 edata = ALIGN( 0x10 ) ;
    60                 _edata = .;
    61         }
     105                copy_start = .;
     106                *(.data)
     107                *(.gnu.linkonce.d*)
     108                *(.gcc_except_table)
     109                . = ALIGN (16);
     110                PROVIDE (_edata = .);
     111                copy_end = .;
     112        } >ram
    62113        .bss : {
    63                 bss_start = . ;
    64                 _bss_start = . ;
    65                 *(.bss)
    66                 *(COMMON)
    67                 . += StackSize; /* XXX -- Old gld can't handle this */
    68                 . = ALIGN (16);
    69                 stack_init = .;
    70                 end = . ;
    71                 _end = . ;
    72         }
     114                bss_start = .;
     115                . += (256 * 4);
     116                clear_start = .;
     117                *(.bss)
     118                *(COMMON)
     119                . = ALIGN (16);
     120                PROVIDE (end = .);
     121
     122                . += StackSize;
     123                PROVIDE (_stack_init = .);
     124
     125                . = ALIGN (16);
     126                PROVIDE (_HeapStart = .);
     127                . += HeapSize;
     128                PROVIDE (_HeapEnd = .);
     129
     130                clear_end = .;
     131
     132                _WorkspaceBase = .;
     133        } >ram
    73134}
  • c/src/lib/libbsp/m68k/efi332/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/efi332/startup/linkcmds

    r69537ca9 rb2b4835  
    3131 */
    3232
     33/*
     34 * Declare some sizes.
     35 */
     36HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
     37StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
     38
    3339MEMORY
    3440{
     
    4450SECTIONS
    4551{
    46   .text :
    47   {
    48     CREATE_OBJECT_SYMBOLS
    49     text_start = .;
    50     _text_start = .;
     52        ram : {
     53                . = .;
     54        } >ram
    5155
    52     *(.text)
    53     . = ALIGN (16);
     56        /*
     57         * Text, data and bss segments
     58         */
     59        .text : {
     60                *(.text)
    5461
    55     *(.eh_fram)
    56     . = ALIGN (16);
     62                /*
     63                 * C++ constructors/destructors
     64                 */
     65                *(.gnu.linkonce.t.*)
    5766
    58     etext = ALIGN(0x10);
    59     _etext = .;
    60     __CTOR_LIST__ = .;
    61     LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    62     *(.ctors)
    63     LONG(0)
    64     __CTOR_END__ = .;
    65     __DTOR_LIST__ = .;
    66     LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    67     *(.dtors)
    68     LONG(0)
    69     __DTOR_END__ = .;
    70     *(.lit)
    71     *(.shdata)
    72     _endtext = .;
    73   } > ram
    74   .gcc_exc :
    75   {
    76     *(.gcc_exc)
    77   } > ram
    78   .data :
    79   {
    80     data_start = .;
    81     _data_start = .;
    82     _sdata = . ;
    83     *(.data)
    84     CONSTRUCTORS
    85     edata = ALIGN(0x10);
    86     _edata = .;
    87   } > ram
    88   .shbss :
    89   {
    90     *(.shbss)
    91   } > ram
    92   .bss :
    93   {
    94     __bss_start = ALIGN(0x8);
    95     bss_start = .;
    96     _bss_start = .;
    97     *(.bss)
    98     *(COMMON)
    99     end = .;
    100     _end = ALIGN(0x8);
    101     __end = ALIGN(0x8);
    102   } > ram
    103   .stab . (NOLOAD) :
    104   {
    105     [ .stab ]
    106   }
    107   .stabstr . (NOLOAD) :
    108   {
    109     [ .stabstr ]
    110   }
     67                /*
     68                 * Initialization and finalization code.
     69                 *
     70                 * Various files can provide initialization and finalization
     71                 * functions.  crtbegin.o and crtend.o are two instances. The
     72                 * body of these functions are in .init and .fini sections. We
     73                 * accumulate the bodies here, and prepend function prologues
     74                 * from crti.o and function epilogues from crtn.o. crti.o must
     75                 * be linked first; crtn.o must be linked last.  Because these
     76                 * are wildcards, it doesn't matter if the user does not
     77                 * actually link against crti.o and crtn.o; the linker won't
     78                 * look for a file to match a wildcard.  The wildcard also
     79                 * means that it doesn't matter which directory crti.o and
     80                 * crtn.o are in.
     81                 */
     82                PROVIDE (_init = .);
     83                *crti.o(.init)
     84                *(.init)
     85                *crtn.o(.init)
     86                PROVIDE (_fini = .);
     87                *crti.o(.fini)
     88                *(.fini)
     89                *crtn.o(.fini)
     90
     91                /*
     92                 * C++ constructors/destructors
     93                 *
     94                 * gcc uses crtbegin.o to find the start of the constructors
     95                 * and destructors so we make sure it is first.  Because this
     96                 * is a wildcard, it doesn't matter if the user does not
     97                 * actually link against crtbegin.o; the linker won't look for
     98                 * a file to match a wildcard.  The wildcard also means that
     99                 * it doesn't matter which directory crtbegin.o is in. The
     100                 * constructor and destructor list are terminated in
     101                 * crtend.o.  The same comments apply to it.
     102                 */
     103                . = ALIGN (16);
     104                *crtbegin.o(.ctors)
     105                *(.ctors)
     106                *crtend.o(.ctors)
     107                *crtbegin.o(.dtors)
     108                *(.dtors)
     109                *crtend.o(.dtors)
     110
     111                /*
     112                 * Exception frame info
     113                 */
     114                . = ALIGN (16);
     115                *(.eh_frame)
     116
     117                /*
     118                 * Read-only data
     119                 */
     120                . = ALIGN (16);
     121                _rodata_start = . ;
     122                *(.rodata)
     123                *(.gnu.linkonce.r*)
     124
     125                 . = ALIGN (16);
     126                PROVIDE (_etext = .);
     127        } >ram
     128        .data : {
     129                PROVIDE (_copy_start = .);
     130                *(.data)
     131                *(.gnu.linkonce.d*)
     132                *(.gcc_except_table)
     133                . = ALIGN (16);
     134                PROVIDE (_edata = .);
     135                PROVIDE (_copy_end = .);
     136        } >ram
     137        .bss : {
     138                PROVIDE (_bss_start = .);
     139                PROVIDE (_clear_start = .);
     140                *(.bss)
     141                *(COMMON)
     142                . = ALIGN (16);
     143                PROVIDE (end = .);
     144
     145                . += StackSize;
     146                PROVIDE (_stack_init = .);
     147
     148                . = ALIGN (16);
     149                PROVIDE (_HeapStart = .);
     150                . += HeapSize;
     151                PROVIDE (_HeapEnd = .);
     152
     153                clear_end = .;
     154
     155                PROVIDE (_WorkspaceBase = .);
     156        } >ram
    111157}
  • c/src/lib/libbsp/m68k/efi68k/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/efi68k/startup/linkcmds

    r69537ca9 rb2b4835  
    4848
    4949/*
     50 * Declare some sizes.
     51 */
     52HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
     53StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
     54
     55/*
    5056 * stick everything in ram (of course)
    5157 */
     58
    5259SECTIONS
    5360{
    54   .text :
    55   {
    56     CREATE_OBJECT_SYMBOLS
    57     text_start = .;
    58     _text_start = .;
    59     *(.text)
    60     . = ALIGN (16);
    61     *(.eh_fram)
    62     . = ALIGN (16);
     61        ram : {
     62                . = .;
     63        } >ram
    6364
    64     etext = ALIGN(0x10);
    65     _etext = .;
    66     __CTOR_LIST__ = .;
    67     LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    68     *(.ctors)
    69     LONG(0)
    70     __CTOR_END__ = .;
    71     __DTOR_LIST__ = .;
    72     LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    73     *(.dtors)
    74     LONG(0)
    75     __DTOR_END__ = .;
    76     *(.lit)
    77     *(.shdata)
    78     _endtext = .;
    79   } > ram
    80   .data :
    81   {
    82     data_start = .;
    83     _data_start = .;
    84     _sdata = . ;
    85     *(.data)
    86     CONSTRUCTORS
    87     edata = ALIGN(0x10);
    88     _edata = .;
    89   } > ram
    90   .shbss :
    91   {
    92     *(.shbss)
    93   } > ram
    94   .bss :
    95   {
    96     __bss_start = ALIGN(0x8);
    97     bss_start = .;
    98     _bss_start = .;
    99     *(.bss)
    100     *(COMMON)
    101     end = .;
    102     _end = ALIGN(0x8);
    103     __end = ALIGN(0x8);
    104   } > ram
    105   .stab . (NOLOAD) :
    106   {
    107     [ .stab ]
    108   }
    109   .stabstr . (NOLOAD) :
    110   {
    111     [ .stabstr ]
    112   }
     65        /*
     66         * Text, data and bss segments
     67         */
     68        .text : {
     69                *(.text)
     70
     71                /*
     72                 * C++ constructors/destructors
     73                 */
     74                *(.gnu.linkonce.t.*)
     75
     76                /*
     77                 * Initialization and finalization code.
     78                 *
     79                 * Various files can provide initialization and finalization
     80                 * functions.  crtbegin.o and crtend.o are two instances. The
     81                 * body of these functions are in .init and .fini sections. We
     82                 * accumulate the bodies here, and prepend function prologues
     83                 * from crti.o and function epilogues from crtn.o. crti.o must
     84                 * be linked first; crtn.o must be linked last.  Because these
     85                 * are wildcards, it doesn't matter if the user does not
     86                 * actually link against crti.o and crtn.o; the linker won't
     87                 * look for a file to match a wildcard.  The wildcard also
     88                 * means that it doesn't matter which directory crti.o and
     89                 * crtn.o are in.
     90                 */
     91                PROVIDE (_init = .);
     92                *crti.o(.init)
     93                *(.init)
     94                *crtn.o(.init)
     95                PROVIDE (_fini = .);
     96                *crti.o(.fini)
     97                *(.fini)
     98                *crtn.o(.fini)
     99
     100                /*
     101                 * C++ constructors/destructors
     102                 *
     103                 * gcc uses crtbegin.o to find the start of the constructors
     104                 * and destructors so we make sure it is first.  Because this
     105                 * is a wildcard, it doesn't matter if the user does not
     106                 * actually link against crtbegin.o; the linker won't look for
     107                 * a file to match a wildcard.  The wildcard also means that
     108                 * it doesn't matter which directory crtbegin.o is in. The
     109                 * constructor and destructor list are terminated in
     110                 * crtend.o.  The same comments apply to it.
     111                 */
     112                . = ALIGN (16);
     113                *crtbegin.o(.ctors)
     114                *(.ctors)
     115                *crtend.o(.ctors)
     116                *crtbegin.o(.dtors)
     117                *(.dtors)
     118                *crtend.o(.dtors)
     119
     120                /*
     121                 * Exception frame info
     122                 */
     123                . = ALIGN (16);
     124                *(.eh_frame)
     125
     126                /*
     127                 * Read-only data
     128                 */
     129                . = ALIGN (16);
     130                _rodata_start = . ;
     131                *(.rodata)
     132                *(.gnu.linkonce.r*)
     133
     134                 . = ALIGN (16);
     135                PROVIDE (_etext = .);
     136        } >ram
     137        .data : {
     138                PROVIDE (_copy_start = .);
     139                *(.data)
     140                *(.gnu.linkonce.d*)
     141                *(.gcc_except_table)
     142                . = ALIGN (16);
     143                PROVIDE (_edata = .);
     144                PROVIDE (_copy_end = .);
     145        } >ram
     146        .bss : {
     147                PROVIDE (_bss_start = .);
     148                PROVIDE (_clear_start = .);
     149                *(.bss)
     150                *(COMMON)
     151                . = ALIGN (16);
     152                PROVIDE (end = .);
     153
     154                . += StackSize;
     155                PROVIDE (_stack_init = .);
     156
     157                . = ALIGN (16);
     158                PROVIDE (_HeapStart = .);
     159                . += HeapSize;
     160                PROVIDE (_HeapEnd = .);
     161
     162                clear_end = .;
     163
     164                PROVIDE (_WorkspaceBase = .);
     165        } >ram
    113166}
  • c/src/lib/libbsp/m68k/gen68302/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/gen68302/startup/linkcmds

    r69537ca9 rb2b4835  
    1414
    1515MEMORY
    16         {
     16{
    1717        ram : org = 0x0000, l = 16M
    18         }
     18}
    1919
    2020m302 = 0xf7f000;
    2121_VBR = 0x000000;                /* location of the VBR table (in RAM) */
    2222
     23/*
     24 * Declare some sizes.
     25 */
     26HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
     27StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
     28
    2329SECTIONS
    2430{
    25         .text 0xc00000 :
    26         {
    27         text_start = . ;
    28         *(.text)
    29         . = ALIGN (16);
    30         *(.gnu.linkonce.t.*)
    31         *(.descriptors)
    32         /* .gnu.warning sections are handled specially by elf32.em.  */
    33         *(.gnu.warning)
     31        ram : {
     32                . = 0xc00000;
     33        } >ram
    3434
    35         *(.eh_fram)
    36         . = ALIGN (16);
     35        /*
     36         * Text, data and bss segments
     37         */
     38        .text : {
     39                *(.text)
    3740
    38         /*
    39          * C++ constructors
    40          */
    41         __CTOR_LIST__ = .;
    42         LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    43         *(.ctors)
    44         LONG(0)
    45         __CTOR_END__ = .;
    46         __DTOR_LIST__ = .;
    47         LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    48         *(.dtors)
    49         LONG(0)
    50         __DTOR_END__ = .;
     41                /*
     42                 * C++ constructors/destructors
     43                 */
     44                *(.gnu.linkonce.t.*)
    5145
    52         _rodata_start = . ;
    53         *(.rodata)
    54         *(.gnu.linkonce.r*)
    55         _erodata = ALIGN( 0x10 ) ;
     46                /*
     47                 * Initialization and finalization code.
     48                 *
     49                 * Various files can provide initialization and finalization
     50                 * functions.  crtbegin.o and crtend.o are two instances. The
     51                 * body of these functions are in .init and .fini sections. We
     52                 * accumulate the bodies here, and prepend function prologues
     53                 * from crti.o and function epilogues from crtn.o. crti.o must
     54                 * be linked first; crtn.o must be linked last.  Because these
     55                 * are wildcards, it doesn't matter if the user does not
     56                 * actually link against crti.o and crtn.o; the linker won't
     57                 * look for a file to match a wildcard.  The wildcard also
     58                 * means that it doesn't matter which directory crti.o and
     59                 * crtn.o are in.
     60                 */
     61                PROVIDE (_init = .);
     62                *crti.o(.init)
     63                *(.init)
     64                *crtn.o(.init)
     65                PROVIDE (_fini = .);
     66                *crti.o(.fini)
     67                *(.fini)
     68                *crtn.o(.fini)
    5669
    57         etext = ALIGN( 0x10 ) ;
    58         }
    59         .data 0x010000 :
    60         {
    61         data_start = . ;
    62         *(.data)
    63         *(.gnu.linkonce.d.*)
    64         *(.gcc_except_table)
    65         edata = ALIGN( 0x10 ) ;
    66         }
    67         .bss ADDR( .data ) + SIZEOF( .data ):
    68         {
    69         bss_start = . ;
    70         *(.bss)
    71         *(COMMON)
    72         end = . ;
    73         _end = . ;
    74         } 
     70                /*
     71                 * C++ constructors/destructors
     72                 *
     73                 * gcc uses crtbegin.o to find the start of the constructors
     74                 * and destructors so we make sure it is first.  Because this
     75                 * is a wildcard, it doesn't matter if the user does not
     76                 * actually link against crtbegin.o; the linker won't look for
     77                 * a file to match a wildcard.  The wildcard also means that
     78                 * it doesn't matter which directory crtbegin.o is in. The
     79                 * constructor and destructor list are terminated in
     80                 * crtend.o.  The same comments apply to it.
     81                 */
     82                . = ALIGN (16);
     83                *crtbegin.o(.ctors)
     84                *(.ctors)
     85                *crtend.o(.ctors)
     86                *crtbegin.o(.dtors)
     87                *(.dtors)
     88                *crtend.o(.dtors)
     89
     90                /*
     91                 * Exception frame info
     92                 */
     93                . = ALIGN (16);
     94                *(.eh_frame)
     95
     96                /*
     97                 * Read-only data
     98                 */
     99                . = ALIGN (16);
     100                _rodata_start = . ;
     101                *(.rodata)
     102                *(.gnu.linkonce.r*)
     103
     104                 . = ALIGN (16);
     105                PROVIDE (_etext = .);
     106        } >ram
     107        .data : {
     108                PROVIDE (_copy_start = .);
     109                *(.data)
     110                *(.gnu.linkonce.d*)
     111                *(.gcc_except_table)
     112                . = ALIGN (16);
     113                PROVIDE (_edata = .);
     114                PROVIDE (_copy_end = .);
     115        } >ram
     116        .bss : {
     117                PROVIDE (_bss_start = .);
     118                PROVIDE (_clear_start = .);
     119                *(.bss)
     120                *(COMMON)
     121                . = ALIGN (16);
     122                PROVIDE (end = .);
     123
     124                . += StackSize;
     125                PROVIDE (_stack_init = .);
     126
     127                . = ALIGN (16);
     128                PROVIDE (_HeapStart = .);
     129                . += HeapSize;
     130                PROVIDE (_HeapEnd = .);
     131
     132                clear_end = .;
     133
     134                PROVIDE (_WorkspaceBase = .);
     135        } >ram
    75136}
  • c/src/lib/libbsp/m68k/gen68340/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/gen68340/startup/linkcmds

    r69537ca9 rb2b4835  
    2525/*
    2626 * Declare some sizes.
    27  * XXX: The assignment of ". += XyzSize;" fails in older gld's if the
    28  *      number used there is not constant.  If this happens to you, edit
    29  *      the lines marked XXX below to use a constant value.
    3027 */
    3128RamSize = DEFINED(RamSize) ? RamSize : 4M;
     
    8077         */
    8178        .text : {
    82                 CREATE_OBJECT_SYMBOLS
    8379                *(.text)
    84                 . = ALIGN (16);
    8580
    8681                /*
    87                  * C++ constructors
     82                 * C++ constructors/destructors
    8883                 */
    89                 __CTOR_LIST__ = .;
    90                 LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
     84                *(.gnu.linkonce.t.*)
     85
     86                /*
     87                 * Initialization and finalization code.
     88                 *
     89                 * Various files can provide initialization and finalization
     90                 * functions.  crtbegin.o and crtend.o are two instances. The
     91                 * body of these functions are in .init and .fini sections. We
     92                 * accumulate the bodies here, and prepend function prologues
     93                 * from crti.o and function epilogues from crtn.o. crti.o must
     94                 * be linked first; crtn.o must be linked last.  Because these
     95                 * are wildcards, it doesn't matter if the user does not
     96                 * actually link against crti.o and crtn.o; the linker won't
     97                 * look for a file to match a wildcard.  The wildcard also
     98                 * means that it doesn't matter which directory crti.o and
     99                 * crtn.o are in.
     100                 */
     101                PROVIDE (_init = .);
     102                *crti.o(.init)
     103                *(.init)
     104                *crtn.o(.init)
     105                PROVIDE (_fini = .);
     106                *crti.o(.fini)
     107                *(.fini)
     108                *crtn.o(.fini)
     109
     110                /*
     111                 * C++ constructors/destructors
     112                 *
     113                 * gcc uses crtbegin.o to find the start of the constructors
     114                 * and destructors so we make sure it is first.  Because this
     115                 * is a wildcard, it doesn't matter if the user does not
     116                 * actually link against crtbegin.o; the linker won't look for
     117                 * a file to match a wildcard.  The wildcard also means that
     118                 * it doesn't matter which directory crtbegin.o is in. The
     119                 * constructor and destructor list are terminated in
     120                 * crtend.o.  The same comments apply to it.
     121                 */
     122                . = ALIGN (16);
     123                *crtbegin.o(.ctors)
    91124                *(.ctors)
    92                 LONG(0)
    93                 __CTOR_END__ = .;
    94                 __DTOR_LIST__ = .;
    95                 LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
     125                *crtend.o(.ctors)
     126                *crtbegin.o(.dtors)
    96127                *(.dtors)
    97                 LONG(0)
    98                 __DTOR_END__ = .;
     128                *crtend.o(.dtors)
    99129
    100                 etext = .;
    101                 _etext = .;
    102         } >rom
     130                /*
     131                 * Exception frame info
     132                 */
     133                . = ALIGN (16);
     134                *(.eh_frame)
    103135
    104         .eh_fram : {
     136                /*
     137                 * Read-only data
     138                 */
    105139                . = ALIGN (16);
    106                 *(.eh_fram)
    107         } >ram
     140                _rodata_start = . ;
     141                *(.rodata)
     142                *(.gnu.linkonce.r*)
    108143
    109         .gcc_exc : {
    110                 . = ALIGN (16);
    111                 *(.gcc_exc)
    112         } >ram
     144                 . = ALIGN (16);
     145                PROVIDE (_etext = .);
     146        } >ram
     147        .data : {
     148                PROVIDE (_copy_start = .);
     149                *(.data)
     150                *(.gnu.linkonce.d*)
     151                *(.gcc_except_table)
     152                . = ALIGN (16);
     153                PROVIDE (_edata = .);
     154                PROVIDE (_copy_end = .);
     155        } >ram
     156        .bss : {
     157                M68Kvec = .;
     158                _M68Kvec = .;
     159                . += (256 * 4);
     160                PROVIDE (_bss_start = .);
     161                PROVIDE (_clear_start = .);
     162                *(.bss)
     163                *(COMMON)
     164                . = ALIGN (16);
     165                PROVIDE (end = .);
     166
     167                . += StackSize;
     168                PROVIDE (_stack_init = .);
     169
     170                . = ALIGN (16);
     171                PROVIDE (_HeapStart = .);
     172                . += HeapSize;
     173                PROVIDE (_HeapEnd = .);
     174
     175                clear_end = .;
     176
     177                PROVIDE (_WorkspaceBase = .);
     178        } >ram
    113179
    114180       /*
     
    122188        } >ram
    123189
    124         .data : {
    125                 copy_start = .;
    126                 *(.data)
    127                 . = ALIGN (16);
    128                 _edata = .;
    129                 copy_end = .;
    130         } >ram
    131 
    132         .bss : {
    133                 M68Kvec = .;
    134                 _M68Kvec = .;
    135                 . += (256 * 4);
    136                 clear_start = .;
    137                 *(.bss)
    138                 *(COMMON)
    139                 . = ALIGN (16);
    140                 _end = .;
    141 
    142                 _HeapStart = .;
    143                 __HeapStart = .;
    144                 . += HeapSize;  /* XXX -- Old gld can't handle this */
    145                 . += StackSize; /* XXX -- Old gld can't handle this */
    146                 /* . += 0x10000; */ /* HeapSize for old gld */
    147                 /* . += 0x1000;  */ /* StackSize for old gld */
    148                 . = ALIGN (16);
    149                 stack_init = .;
    150                 clear_end = .;
    151 
    152                 _WorkspaceBase = .;
    153                 __WorkspaceBase = .;
    154         } >ram
    155190}
  • c/src/lib/libbsp/m68k/gen68360/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/gen68360/startup/linkcmds

    r69537ca9 rb2b4835  
    1414/*
    1515 * Declare some sizes.
    16  * XXX: The assignment of ". += XyzSize;" fails in older gld's if the
    17  *      number used there is not constant.  If this happens to you, edit
    18  *      the lines marked XXX below to use a constant value.
    1916 */
    2017HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
     
    3936        rom : {
    4037                _RomBase = .;
    41                 __RomBase = .;
    4238        } >rom
    4339
     
    4743        ram : {
    4844                _RamBase = .;
    49                 __RamBase = .;
    5045        } >ram
    5146
     
    5449         */
    5550        .text : {
    56                 CREATE_OBJECT_SYMBOLS
    5751                *(.text)
    58                 . = ALIGN (16);
    5952
     53                /*
     54                 * C++ constructors/destructors
     55                 */
    6056                *(.gnu.linkonce.t.*)
    61                 *(.descriptors)
    62                 /* .gnu.warning sections are handled specially by elf32.em.  */
    63                 *(.gnu.warning)
    6457
    65                 *(.eh_fram)
     58                /*
     59                 * Initialization and finalization code.
     60                 *
     61                 * Various files can provide initialization and finalization
     62                 * functions.  crtbegin.o and crtend.o are two instances. The
     63                 * body of these functions are in .init and .fini sections. We
     64                 * accumulate the bodies here, and prepend function prologues
     65                 * from crti.o and function epilogues from crtn.o. crti.o must
     66                 * be linked first; crtn.o must be linked last.  Because these
     67                 * are wildcards, it doesn't matter if the user does not
     68                 * actually link against crti.o and crtn.o; the linker won't
     69                 * look for a file to match a wildcard.  The wildcard also
     70                 * means that it doesn't matter which directory crti.o and
     71                 * crtn.o are in.
     72                 */
     73                PROVIDE (_init = .);
     74                *crti.o(.init)
     75                *(.init)
     76                *crtn.o(.init)
     77                PROVIDE (_fini = .);
     78                *crti.o(.fini)
     79                *(.fini)
     80                *crtn.o(.fini)
     81
     82                /*
     83                 * C++ constructors/destructors
     84                 *
     85                 * gcc uses crtbegin.o to find the start of the constructors
     86                 * and destructors so we make sure it is first.  Because this
     87                 * is a wildcard, it doesn't matter if the user does not
     88                 * actually link against crtbegin.o; the linker won't look for
     89                 * a file to match a wildcard.  The wildcard also means that
     90                 * it doesn't matter which directory crtbegin.o is in. The
     91                 * constructor and destructor list are terminated in
     92                 * crtend.o.  The same comments apply to it.
     93                 */
    6694                . = ALIGN (16);
     95                *crtbegin.o(.ctors)
     96                *(.ctors)
     97                *crtend.o(.ctors)
     98                *crtbegin.o(.dtors)
     99                *(.dtors)
     100                *crtend.o(.dtors)
    67101
    68                 *(.gcc_exc)
    69102                /*
    70                  * C++ constructors
     103                 * Exception frame info
    71104                 */
    72                 __CTOR_LIST__ = .;
    73                 LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    74                 *(.ctors)
    75                 LONG(0)
    76                 __CTOR_END__ = .;
    77                 __DTOR_LIST__ = .;
    78                 LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    79                 *(.dtors)
    80                 LONG(0)
    81                 __DTOR_END__ = .;
     105                . = ALIGN (16);
     106                *(.eh_frame)
    82107
     108                /*
     109                 * Read-only data
     110                 */
     111                . = ALIGN (16);
    83112                _rodata_start = . ;
    84113                *(.rodata)
     
    86115
    87116                 . = ALIGN (16);
    88                 etext = .;
    89                 _etext = .;
    90         } >ram
     117                PROVIDE (etext = .);
     118        } >ram
    91119        .data : {
    92120                copy_start = .;
     
    95123                *(.gcc_except_table)
    96124                . = ALIGN (16);
    97                 _edata = .;
     125                PROVIDE (_edata = .);
    98126                copy_end = .;
    99127        } >ram
     
    106134                *(COMMON)
    107135                . = ALIGN (16);
    108                 _end = .;
     136                PROVIDE (end = .);
    109137
    110                 _HeapStart = .;
    111                 __HeapStart = .;
    112                 . += HeapSize;  /* XXX -- Old gld can't handle this */
    113                 . += StackSize; /* XXX -- Old gld can't handle this */
    114                 /* . += 0x10000; */ /* HeapSize for old gld */
    115                 /* . += 0x1000;  */ /* StackSize for old gld */
     138                . += StackSize;
     139                PROVIDE (_stack_init = .);
     140
    116141                . = ALIGN (16);
    117                 stack_init = .;
     142                PROVIDE (_HeapStart = .);
     143                . += HeapSize;
     144                PROVIDE (_HeapEnd = .);
     145
    118146                clear_end = .;
    119147
    120148                _WorkspaceBase = .;
    121                 __WorkspaceBase = .;
    122149        } >ram
    123150
  • c/src/lib/libbsp/m68k/idp/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/idp/startup/linkcmds

    r69537ca9 rb2b4835  
    1313 */
    1414
    15 StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
    16 
    1715MEMORY
    1816{
     
    2018}
    2119
     20/*
     21 * Declare some sizes.
     22 */
     23HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
     24StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
     25
    2226SECTIONS
    2327{
    24     .text 0x10000: 
    25     {
    26         text_start = . ;
    27         _text_start = . ;
    28         *(.text)
    29         . = ALIGN (16);
     28        ram : {
     29                . = .;
     30        } >ram
    3031
    31         *(.eh_fram)
    32         . = ALIGN (16);
     32        /*
     33         * Text, data and bss segments
     34         */
     35        .text : {
     36                *(.text)
    3337
    34         . = ALIGN (16);
    35         *(.gcc_exc)
     38                /*
     39                 * C++ constructors/destructors
     40                 */
     41                *(.gnu.linkonce.t.*)
    3642
    37         /*
    38          * C++ constructors
    39          */
    40         __CTOR_LIST__ = .;
    41         LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    42         *(.ctors)
    43         LONG(0)
    44         __CTOR_END__ = .;
    45         __DTOR_LIST__ = .;
    46         LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    47         *(.dtors)
    48         LONG(0)
    49         __DTOR_END__ = .;
    50         etext = ALIGN( 0x10 ) ;
    51         _etext = .;
    52     }
    53     .data : {
    54         data_start = . ;
    55         _data_start = .;
    56         *(.data)
    57         edata = ALIGN( 0x10 ) ;
    58         _edata = .;
    59     }
    60     .bss : {
    61         bss_start = . ;
    62         _bss_start = . ;
    63         *(.bss)
    64         *(COMMON)
    65         . += StackSize; /* XXX -- Old gld can't handle this */
    66         . = ALIGN (16);
    67         stack_init = .;
    68         end = . ;
    69         _end = . ;
    70     } 
     43                /*
     44                 * Initialization and finalization code.
     45                 *
     46                 * Various files can provide initialization and finalization
     47                 * functions.  crtbegin.o and crtend.o are two instances. The
     48                 * body of these functions are in .init and .fini sections. We
     49                 * accumulate the bodies here, and prepend function prologues
     50                 * from crti.o and function epilogues from crtn.o. crti.o must
     51                 * be linked first; crtn.o must be linked last.  Because these
     52                 * are wildcards, it doesn't matter if the user does not
     53                 * actually link against crti.o and crtn.o; the linker won't
     54                 * look for a file to match a wildcard.  The wildcard also
     55                 * means that it doesn't matter which directory crti.o and
     56                 * crtn.o are in.
     57                 */
     58                PROVIDE (_init = .);
     59                *crti.o(.init)
     60                *(.init)
     61                *crtn.o(.init)
     62                PROVIDE (_fini = .);
     63                *crti.o(.fini)
     64                *(.fini)
     65                *crtn.o(.fini)
     66
     67                /*
     68                 * C++ constructors/destructors
     69                 *
     70                 * gcc uses crtbegin.o to find the start of the constructors
     71                 * and destructors so we make sure it is first.  Because this
     72                 * is a wildcard, it doesn't matter if the user does not
     73                 * actually link against crtbegin.o; the linker won't look for
     74                 * a file to match a wildcard.  The wildcard also means that
     75                 * it doesn't matter which directory crtbegin.o is in. The
     76                 * constructor and destructor list are terminated in
     77                 * crtend.o.  The same comments apply to it.
     78                 */
     79                . = ALIGN (16);
     80                *crtbegin.o(.ctors)
     81                *(.ctors)
     82                *crtend.o(.ctors)
     83                *crtbegin.o(.dtors)
     84                *(.dtors)
     85                *crtend.o(.dtors)
     86
     87                /*
     88                 * Exception frame info
     89                 */
     90                . = ALIGN (16);
     91                *(.eh_frame)
     92
     93                /*
     94                 * Read-only data
     95                 */
     96                . = ALIGN (16);
     97                _rodata_start = . ;
     98                *(.rodata)
     99                *(.gnu.linkonce.r*)
     100
     101                 . = ALIGN (16);
     102                PROVIDE (_etext = .);
     103        } >ram
     104        .data : {
     105                PROVIDE (_copy_start = .);
     106                *(.data)
     107                *(.gnu.linkonce.d*)
     108                *(.gcc_except_table)
     109                . = ALIGN (16);
     110                PROVIDE (_edata = .);
     111                PROVIDE (_copy_end = .);
     112        } >ram
     113        .bss : {
     114                PROVIDE (_bss_start = .);
     115                PROVIDE (_clear_start = .);
     116                *(.bss)
     117                *(COMMON)
     118                . = ALIGN (16);
     119                PROVIDE (end = .);
     120
     121                . += StackSize;
     122                PROVIDE (_stack_init = .);
     123
     124                . = ALIGN (16);
     125                PROVIDE (_HeapStart = .);
     126                . += HeapSize;
     127                PROVIDE (_HeapEnd = .);
     128
     129                clear_end = .;
     130
     131                PROVIDE (_WorkspaceBase = .);
     132        } >ram
    71133}
  • c/src/lib/libbsp/m68k/mvme136/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/mvme136/startup/linkcmds

    r69537ca9 rb2b4835  
    1313 */
    1414
     15/*
     16 * Declare some sizes.
     17 */
     18HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
    1519StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
     20
    1621MEMORY
    17         {
    18         ram : org = 0x3000, l = 1M
    19         }
     22{
     23        ram : org = 0x0, l = 1M
     24}
    2025
    2126SECTIONS
    2227{
    23         .text 0x3000 :
    24         {
    25             text_start = . ;
    26             _text_start = . ;
    27             *(.text)
    28             . = ALIGN (16);
     28        ram : {
     29                . = 0x3000;
     30        } >ram
    2931
    30             *(.eh_fram)
    31             . = ALIGN (16);
     32        /*
     33         * Text, data and bss segments
     34         */
     35        .text : {
     36                *(.text)
    3237
    33             /*
    34              * C++ constructors
    35              */
    36             __CTOR_LIST__ = .;
    37             LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    38             *(.ctors)
    39             LONG(0)
    40             __CTOR_END__ = .;
    41             __DTOR_LIST__ = .;
    42             LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    43             *(.dtors)
    44             LONG(0)
    45             __DTOR_END__ = .;
    46             etext = ALIGN( 0x10 ) ;
    47             _etext = .;
    48         }
     38                /*
     39                 * C++ constructors/destructors
     40                 *
     41                 * Various files can provide initialization and finalization
     42                 * functions.  crtbegin.o and crtend.o are two instances. The
     43                 * body of these functions are in .init and .fini sections. We
     44                 * accumulate the bodies here, and prepend function prologues
     45                 * from crti.o and function epilogues from crtn.o. crti.o must
     46                 * be linked first; crtn.o must be linked last.  Because these
     47                 * are wildcards, it doesn't matter if the user does not
     48                 * actually link against crti.o and crtn.o; the linker won't
     49                 * look for a file to match a wildcard.  The wildcard also
     50                 * means that it doesn't matter which directory crti.o and
     51                 * crtn.o are in.
     52                 */
     53                *(.gnu.linkonce.t.*)
     54
     55                /*
     56                 * Initialization and finalization code.
     57                 *
     58                 * gcc uses crtbegin.o to find the start of the constructors
     59                 * and destructors so we make sure it is first.  Because this
     60                 * is a wildcard, it doesn't matter if the user does not
     61                 * actually link against crtbegin.o; the linker won't look for
     62                 * a file to match a wildcard.  The wildcard also means that
     63                 * it doesn't matter which directory crtbegin.o is in. The
     64                 * constructor and destructor list are terminated in
     65                 * crtend.o.  The same comments apply to it.
     66                 */
     67                PROVIDE (_init = .);
     68                *crti.o(.init)
     69                *(.init)
     70                *crtn.o(.init)
     71                PROVIDE (_fini = .);
     72                *crti.o(.fini)
     73                *(.fini)
     74                *crtn.o(.fini)
     75
     76                /*
     77                 * C++ constructors/destructors
     78                 */
     79                . = ALIGN (16);
     80                *crtbegin.o(.ctors)
     81                *(.ctors)
     82                *crtend.o(.ctors)
     83                *crtbegin.o(.dtors)
     84                *(.dtors)
     85                *crtend.o(.dtors)
     86
     87                /*
     88                 * Exception frame info
     89                 */
     90                . = ALIGN (16);
     91                *(.eh_frame)
     92
     93                /*
     94                 * Read-only data
     95                 */
     96                . = ALIGN (16);
     97                _rodata_start = . ;
     98                *(.rodata)
     99                *(.gnu.linkonce.r*)
     100
     101                 . = ALIGN (16);
     102                PROVIDE (_etext = .);
     103        } >ram
    49104        .data : {
    50             data_start = . ;
    51             _data_start = .;
    52             *(.data)
    53             edata = ALIGN( 0x10 ) ;
    54             _edata = .;
    55         }
     105                PROVIDE (_copy_start = .);
     106                *(.data)
     107                *(.gnu.linkonce.d*)
     108                *(.gcc_except_table)
     109                . = ALIGN (16);
     110                PROVIDE (_edata = .);
     111                PROVIDE (_copy_end = .);
     112        } >ram
    56113        .bss : {
    57             bss_start = . ;
    58             _bss_start = . ;
    59             *(.bss)
    60             *(COMMON)
    61                 . += StackSize; /* XXX -- Old gld can't handle this */
     114                PROVIDE (_bss_start = .);
     115                PROVIDE (_clear_start = .);
     116                *(.bss)
     117                *(COMMON)
    62118                . = ALIGN (16);
    63                 stack_init = .;
    64             end = . ;
    65             _end = . ;
    66         }
     119                PROVIDE (end = .);
     120
     121                . += StackSize;
     122                PROVIDE (_stack_init = .);
     123
     124                . = ALIGN (16);
     125                PROVIDE (_HeapStart = .);
     126                . += HeapSize;
     127                PROVIDE (_HeapEnd = .);
     128
     129                clear_end = .;
     130
     131                PROVIDE (_WorkspaceBase = .);
     132        } >ram
    67133}
  • c/src/lib/libbsp/m68k/mvme147/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/mvme147/startup/linkcmds

    r69537ca9 rb2b4835  
    1717 */
    1818
     19/*
     20 * Declare some sizes.
     21 */
     22HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
    1923StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
    2024
    2125MEMORY
    22         {
    23         ram : org = 0x5000, l = 0x3fafff
    24         }
     26{
     27        ram : org = 0x0, l = 0x400000
     28}
    2529
    2630SECTIONS
    2731{
    28         .text 0x5000 :
    29         {
    30             text_start = . ;
    31             _text_start = . ;
    32             *(.text)
    33             . = ALIGN (16);
     32        ram : {
     33                . = 0x5000;
     34        } >ram
    3435
    35             *(.eh_fram)
    36             . = ALIGN (16);
     36        /*
     37         * Text, data and bss segments
     38         */
     39        .text : {
     40                *(.text)
    3741
    38             /*
    39              * C++ constructors
    40              */
    41             __CTOR_LIST__ = .;
    42             LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    43             *(.ctors)
    44             LONG(0)
    45             __CTOR_END__ = .;
    46             __DTOR_LIST__ = .;
    47             LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    48             *(.dtors)
    49             LONG(0)
    50             __DTOR_END__ = .;
    51             etext = ALIGN( 0x10 ) ;
    52             _etext = .;
    53         }
     42                /*
     43                 * C++ constructors/destructors
     44                 */
     45                *(.gnu.linkonce.t.*)
     46
     47                /*
     48                 * Initialization and finalization code.
     49                 *
     50                 * Various files can provide initialization and finalization
     51                 * functions.  crtbegin.o and crtend.o are two instances. The
     52                 * body of these functions are in .init and .fini sections. We
     53                 * accumulate the bodies here, and prepend function prologues
     54                 * from crti.o and function epilogues from crtn.o. crti.o must
     55                 * be linked first; crtn.o must be linked last.  Because these
     56                 * are wildcards, it doesn't matter if the user does not
     57                 * actually link against crti.o and crtn.o; the linker won't
     58                 * look for a file to match a wildcard.  The wildcard also
     59                 * means that it doesn't matter which directory crti.o and
     60                 * crtn.o are in.
     61                 */
     62                PROVIDE (_init = .);
     63                *crti.o(.init)
     64                *(.init)
     65                *crtn.o(.init)
     66                PROVIDE (_fini = .);
     67                *crti.o(.fini)
     68                *(.fini)
     69                *crtn.o(.fini)
     70
     71                /*
     72                 * C++ constructors/destructors
     73                 *
     74                 * gcc uses crtbegin.o to find the start of the constructors
     75                 * and destructors so we make sure it is first.  Because this
     76                 * is a wildcard, it doesn't matter if the user does not
     77                 * actually link against crtbegin.o; the linker won't look for
     78                 * a file to match a wildcard.  The wildcard also means that
     79                 * it doesn't matter which directory crtbegin.o is in. The
     80                 * constructor and destructor list are terminated in
     81                 * crtend.o.  The same comments apply to it.
     82                 */
     83                . = ALIGN (16);
     84                *crtbegin.o(.ctors)
     85                *(.ctors)
     86                *crtend.o(.ctors)
     87                *crtbegin.o(.dtors)
     88                *(.dtors)
     89                *crtend.o(.dtors)
     90
     91                /*
     92                 * Exception frame info
     93                 */
     94                . = ALIGN (16);
     95                *(.eh_frame)
     96
     97                /*
     98                 * Read-only data
     99                 */
     100                . = ALIGN (16);
     101                _rodata_start = . ;
     102                *(.rodata)
     103                *(.gnu.linkonce.r*)
     104
     105                 . = ALIGN (16);
     106                PROVIDE (_etext = .);
     107        } >ram
    54108        .data : {
    55             data_start = . ;
    56             _data_start = .;
    57             *(.data)
    58             edata = ALIGN( 0x10 ) ;
    59             _edata = .;
    60         }
     109                PROVIDE (_copy_start = .);
     110                *(.data)
     111                *(.gnu.linkonce.d*)
     112                *(.gcc_except_table)
     113                . = ALIGN (16);
     114                PROVIDE (_edata = .);
     115                PROVIDE (_copy_end = .);
     116        } >ram
    61117        .bss : {
    62             bss_start = . ;
    63             _bss_start = . ;
    64             *(.bss)
    65             *(COMMON)
    66             . += StackSize; /* XXX -- Old gld can't handle this */
    67             . = ALIGN (16);
    68             stack_init = .;
    69             end = . ;
    70             _end = . ;
    71         }
     118                PROVIDE (_bss_start = .);
     119                PROVIDE (_clear_start = .);
     120                *(.bss)
     121                *(COMMON)
     122                . = ALIGN (16);
     123                PROVIDE (end = .);
     124
     125                . += StackSize;
     126                PROVIDE (_stack_init = .);
     127
     128                . = ALIGN (16);
     129                PROVIDE (_HeapStart = .);
     130                . += HeapSize;
     131                PROVIDE (_HeapEnd = .);
     132
     133                clear_end = .;
     134
     135                PROVIDE (_WorkspaceBase = .);
     136        } >ram
    72137}
  • c/src/lib/libbsp/m68k/mvme147s/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/mvme147s/startup/linkcmds

    r69537ca9 rb2b4835  
    1717 */
    1818
     19/*
     20 * Declare some sizes.
     21 */
     22HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
    1923StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
    2024
    2125MEMORY
    22         {
    23         ram : org = 0x7000, l = 0x3d8fff
    24         }
     26{
     27        ram : org = 0x0, l = 0x400000
     28}
    2529
    2630SECTIONS
    2731{
    28         .text 0x7000 :
    29         {
    30             text_start = . ;
    31             _text_start = . ;
    32             *(.text)
    33             . = ALIGN (16);
     32        ram : {
     33                . = 0x7000;
     34        } >ram
    3435
    35             *(.gnu.linkonce.t.*)
    36             *(.descriptors)
    37             /* .gnu.warning sections are handled specially by elf32.em.  */
    38             *(.gnu.warning)
     36        /*
     37         * Text, data and bss segments
     38         */
     39        .text : {
     40                *(.text)
    3941
    40             *(.eh_fram)
    41             . = ALIGN (16);
     42                /*
     43                 * C++ constructors/destructors
     44                 */
     45                *(.gnu.linkonce.t.*)
    4246
    43             /*
    44              * C++ constructors
    45              */
    46             __CTOR_LIST__ = .;
    47             LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    48             *(.ctors)
    49             LONG(0)
    50             __CTOR_END__ = .;
    51             __DTOR_LIST__ = .;
    52             LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    53             *(.dtors)
    54             LONG(0)
    55             __DTOR_END__ = .;
     47                /*
     48                 * Initialization and finalization code.
     49                 *
     50                 * Various files can provide initialization and finalization
     51                 * functions.  crtbegin.o and crtend.o are two instances. The
     52                 * body of these functions are in .init and .fini sections. We
     53                 * accumulate the bodies here, and prepend function prologues
     54                 * from crti.o and function epilogues from crtn.o. crti.o must
     55                 * be linked first; crtn.o must be linked last.  Because these
     56                 * are wildcards, it doesn't matter if the user does not
     57                 * actually link against crti.o and crtn.o; the linker won't
     58                 * look for a file to match a wildcard.  The wildcard also
     59                 * means that it doesn't matter which directory crti.o and
     60                 * crtn.o are in.
     61                 */
     62                PROVIDE (_init = .);
     63                *crti.o(.init)
     64                *(.init)
     65                *crtn.o(.init)
     66                PROVIDE (_fini = .);
     67                *crti.o(.fini)
     68                *(.fini)
     69                *crtn.o(.fini)
    5670
    57             _rodata_start = . ;
    58             *(.rodata)
    59             *(.gnu.linkonce.r*)
    60             _erodata = ALIGN( 0x10 ) ;
     71                /*
     72                 * C++ constructors/destructors
     73                 *
     74                 * gcc uses crtbegin.o to find the start of the constructors
     75                 * and destructors so we make sure it is first.  Because this
     76                 * is a wildcard, it doesn't matter if the user does not
     77                 * actually link against crtbegin.o; the linker won't look for
     78                 * a file to match a wildcard.  The wildcard also means that
     79                 * it doesn't matter which directory crtbegin.o is in. The
     80                 * constructor and destructor list are terminated in
     81                 * crtend.o.  The same comments apply to it.
     82                 */
     83                . = ALIGN (16);
     84                *crtbegin.o(.ctors)
     85                *(.ctors)
     86                *crtend.o(.ctors)
     87                *crtbegin.o(.dtors)
     88                *(.dtors)
     89                *crtend.o(.dtors)
    6190
    62             etext = ALIGN( 0x10 ) ;
    63             _etext = .;
    64         }
    65         .data ADDR( .text ) + SIZEOF( .text ):
    66         {
    67             data_start = . ;
    68             _data_start = .;
    69             *(.data)
    70             *(.gnu.linkonce.d*)
    71             *(.gcc_except_table)
    72             edata = ALIGN( 0x10 ) ;
    73             _edata = .;
    74         }
    75         .bss ADDR( .data ) + SIZEOF( .data ):
    76         {
    77             bss_start = . ;
    78             _bss_start = . ;
    79             *(.bss)
    80             *(COMMON)
    81             . += StackSize; /* XXX -- Old gld can't handle this */
    82             . = ALIGN (16);
    83             stack_init = .;
    84             end = . ;
    85             _end = . ;
    86         }
     91                /*
     92                 * Exception frame info
     93                 */
     94                . = ALIGN (16);
     95                *(.eh_frame)
     96
     97                /*
     98                 * Read-only data
     99                 */
     100                . = ALIGN (16);
     101                _rodata_start = . ;
     102                *(.rodata)
     103                *(.gnu.linkonce.r*)
     104
     105                 . = ALIGN (16);
     106                PROVIDE (_etext = .);
     107        } >ram
     108        .data : {
     109                PROVIDE (_copy_start = .);
     110                *(.data)
     111                *(.gnu.linkonce.d*)
     112                *(.gcc_except_table)
     113                . = ALIGN (16);
     114                PROVIDE (_edata = .);
     115                PROVIDE (_copy_end = .);
     116        } >ram
     117        .bss : {
     118                PROVIDE (_bss_start = .);
     119                PROVIDE (_clear_start = .);
     120                *(.bss)
     121                *(COMMON)
     122                . = ALIGN (16);
     123                PROVIDE (end = .);
     124
     125                . += StackSize;
     126                PROVIDE (_stack_init = .);
     127
     128                . = ALIGN (16);
     129                PROVIDE (_HeapStart = .);
     130                . += HeapSize;
     131                PROVIDE (_HeapEnd = .);
     132
     133                clear_end = .;
     134
     135                PROVIDE (_WorkspaceBase = .);
     136        } >ram
    87137}
  • c/src/lib/libbsp/m68k/mvme162/bsp_specs

    r69537ca9 rb2b4835  
    2020%{!qrtems: %(old_startfile)} %{qrtems: \
    2121%{!qrtems_debug: start.o%s} \
    22 %{qrtems_debug: start_g.o%s}}
     22%{qrtems_debug: start_g.o%s} \
     23crti.o%s crtbegin.o%s}
    2324
    2425*link:
    2526%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2627
     28*endfile:
     29%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     30
  • c/src/lib/libbsp/m68k/mvme162/startup/linkcmds

    r69537ca9 rb2b4835  
    2020 */
    2121
     22/*
     23 * Declare some sizes.
     24 */
     25HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
    2226StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
    2327
    2428MEMORY
    25         {
     29{
    2630        ram : org = 0x100000, l = 1M
    27         }
     31}
    2832
    2933SECTIONS
    3034{
    31         .text 0x100000 :
    32         {
    33         text_start = . ;
    34         *(.text)
    35         . = ALIGN (16);
     35        ram : {
     36                . = .;
     37        } >ram
    3638
    37         *(.eh_fram)
    38         . = ALIGN (16);
     39        /*
     40         * Text, data and bss segments
     41         */
     42        .text : {
     43                *(.text)
    3944
    40         /*
    41          * C++ constructors
    42          */
    43         __CTOR_LIST__ = .;
    44         LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    45         *(.ctors)
    46         LONG(0)
    47         __CTOR_END__ = .;
    48         __DTOR_LIST__ = .;
    49         LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    50         *(.dtors)
    51         LONG(0)
    52         __DTOR_END__ = .;
    53         etext = ALIGN( 0x10 ) ;
    54         }
     45                /*
     46                 * C++ constructors/destructors
     47                 */
     48                *(.gnu.linkonce.t.*)
     49
     50                /*
     51                 * Initialization and finalization code.
     52                 *
     53                 * Various files can provide initialization and finalization
     54                 * functions.  crtbegin.o and crtend.o are two instances. The
     55                 * body of these functions are in .init and .fini sections. We
     56                 * accumulate the bodies here, and prepend function prologues
     57                 * from crti.o and function epilogues from crtn.o. crti.o must
     58                 * be linked first; crtn.o must be linked last.  Because these
     59                 * are wildcards, it doesn't matter if the user does not
     60                 * actually link against crti.o and crtn.o; the linker won't
     61                 * look for a file to match a wildcard.  The wildcard also
     62                 * means that it doesn't matter which directory crti.o and
     63                 * crtn.o are in.
     64                 */
     65                PROVIDE (_init = .);
     66                *crti.o(.init)
     67                *(.init)
     68                *crtn.o(.init)
     69                PROVIDE (_fini = .);
     70                *crti.o(.fini)
     71                *(.fini)
     72                *crtn.o(.fini)
     73
     74                /*
     75                 * C++ constructors/destructors
     76                 *
     77                 * gcc uses crtbegin.o to find the start of the constructors
     78                 * and destructors so we make sure it is first.  Because this
     79                 * is a wildcard, it doesn't matter if the user does not
     80                 * actually link against crtbegin.o; the linker won't look for
     81                 * a file to match a wildcard.  The wildcard also means that
     82                 * it doesn't matter which directory crtbegin.o is in. The
     83                 * constructor and destructor list are terminated in
     84                 * crtend.o.  The same comments apply to it.
     85                 */
     86                . = ALIGN (16);
     87                *crtbegin.o(.ctors)
     88                *(.ctors)
     89                *crtend.o(.ctors)
     90                *crtbegin.o(.dtors)
     91                *(.dtors)
     92                *crtend.o(.dtors)
     93
     94                /*
     95                 * Exception frame info
     96                 */
     97                . = ALIGN (16);
     98                *(.eh_frame)
     99
     100                /*
     101                 * Read-only data
     102                 */
     103                . = ALIGN (16);
     104                _rodata_start = . ;
     105                *(.rodata)
     106                *(.gnu.linkonce.r*)
     107
     108                 . = ALIGN (16);
     109                PROVIDE (_etext = .);
     110        } >ram
    55111        .data : {
    56         data_start = . ;
    57         *(.data)
    58         edata = ALIGN( 0x10 ) ;
    59         }
     112                PROVIDE (_copy_start = .);
     113                *(.data)
     114                *(.gnu.linkonce.d*)
     115                *(.gcc_except_table)
     116                . = ALIGN (16);
     117                PROVIDE (_edata = .);
     118                PROVIDE (_copy_end = .);
     119        } >ram
    60120        .bss : {
    61         bss_start = . ;
    62         *(.bss)
    63         *(COMMON)
    64         . += StackSize; /* XXX -- Old gld can't handle this */
    65         . = ALIGN (16);
    66         stack_init = .;
    67         end = . ;
    68         _end = . ;
    69         }
     121                PROVIDE (_bss_start = .);
     122                PROVIDE (_clear_start = .);
     123                *(.bss)
     124                *(COMMON)
     125                . = ALIGN (16);
     126                PROVIDE (end = .);
     127
     128                . += StackSize;
     129                PROVIDE (_stack_init = .);
     130
     131                . = ALIGN (16);
     132                PROVIDE (_HeapStart = .);
     133                . += HeapSize;
     134                PROVIDE (_HeapEnd = .);
     135
     136                clear_end = .;
     137
     138                PROVIDE (_WorkspaceBase = .);
     139        } >ram
    70140}
  • c/src/lib/libbsp/m68k/mvme167/bsp_specs

    r69537ca9 rb2b4835  
    2121%{!qrtems: %(old_startfile)} %{qrtems: \
    2222%{!qrtems_debug: start.o%s} \
    23 %{qrtems_debug: start_g.o%s} %{qelf crti.o%s crtbegin.o%s}}
     23%{qrtems_debug: start_g.o%s} \
     24crti.o%s crtbegin.o%s}
    2425
    2526*link:
    2627%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2728
     29*endfile:
     30%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     31
  • c/src/lib/libbsp/m68k/mvme167/startup/linkcmds

    r69537ca9 rb2b4835  
    3030/*
    3131 * Declare some sizes.
    32  * XXX: The assignment of ". += XyzSize;" fails in older gld's if the
    33  *      number used there is not constant.  If this happens to you, edit
    34  *      the lines marked XXX below to use a constant value.
    3532 */
    3633HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
     
    5047SECTIONS
    5148{
    52   /*
    53    * We want the entry point to be the first thing in memory.
    54    * Merge all read-only data into the .text section.
    55    */
    56   .text 0x00800000 :
    57   {
    58     text_start = . ;
    59    
    60     *(.text)
    61     *(.text.*)
    62     *(.stub)
     49        ram : {
     50                . = .;
     51        } >ram
    6352
    64     /* C++ constructors/destructors */
    65     *(.gnu.linkonce.t*)
    66    
    67     /* Initialization and finalization code.
    68      *
    69      * Various files can provide initialization and finalization functions.
    70      * crtbegin.o and crtend.o are two instances. The body of these functions
    71      * are in .init and .fini sections. We accumulate the bodies here, and
    72      * prepend function prologues from crti.o and function epilogues from
    73      * crtn.o. crti.o must be linked first; crtn.o must be linked last.
    74      * Because these are wildcards, it doesn't matter if the user does not
    75      * actually link against crti.o and crtn.o; the linker won't look for a
    76      * file to match a wildcard.  The wildcard also means that it doesn't
    77      * matter which directory crti.o and crtn.o are in.
    78      */
    79     PROVIDE (_init = .);
    80     *crti.o(.init)
    81     *(.init)
    82     *crtn.o(.init)
    83    
    84     PROVIDE (_fini = .);
    85     *crti.o(.fini)
    86     *(.fini)
    87     *crtn.o(.init)
    88    
    89     . = ALIGN (16);
    90    
    91     /* C++ constructors and destructors for static objects.
    92      *
    93      * gcc uses crtbegin.o to find the start of the constructors and
    94      * destructors so we make sure it is first.  Because this is a wildcard,
    95      * it doesn't matter if the user does not actually link against
    96      * crtbegin.o; the linker won't look for a file to match a wildcard.  The
    97      * wildcard also means that it doesn't matter which directory crtbegin.o
    98      * is in. The constructor and destructor list are terminated in crtend.o.
    99      * The same comments apply to it.
    100      */
    101     PROVIDE (__CTOR_LIST__ = .);
    102     *crtbegin.o(.ctors)
    103     *(.ctors)
    104     *crtend.o(.ctors)
    105     PROVIDE (__CTOR_END__ = .);
     53        /*
     54         * Text, data and bss segments
     55         */
     56        .text : {
     57                *(.text)
    10658
    107     PROVIDE (__DTOR_LIST__ = .);
    108     *crtbegin.o(.dtors)
    109     *(.dtors)
    110     *crtend.o(.dtors)
    111     PROVIDE (__DTOR_END__ = .);
    112    
    113     . = ALIGN (16);
    114    
    115     /* Exception frame info */
    116     *(.eh_frame)
    117    
    118     . = ALIGN (16);
     59                /*
     60                 * C++ constructors/destructors
     61                 */
     62                *(.gnu.linkonce.t.*)
    11963
    120     /* Do we have any of these with egcs-1.x and higher? */
    121     *(.gcc_exc)
    122    
    123     . = ALIGN (16);
    124                
    125     _rodata_start = . ;
    126     *(.rodata)
    127     *(.rodata.*)
    128     *(.gnu.linkonce.r*)
    129     *(.rodata1)   
    130     _erodata = .;
     64                /*
     65                 * Initialization and finalization code.
     66                 *
     67                 * Various files can provide initialization and finalization
     68                 * functions.  crtbegin.o and crtend.o are two instances. The
     69                 * body of these functions are in .init and .fini sections. We
     70                 * accumulate the bodies here, and prepend function prologues
     71                 * from crti.o and function epilogues from crtn.o. crti.o must
     72                 * be linked first; crtn.o must be linked last.  Because these
     73                 * are wildcards, it doesn't matter if the user does not
     74                 * actually link against crti.o and crtn.o; the linker won't
     75                 * look for a file to match a wildcard.  The wildcard also
     76                 * means that it doesn't matter which directory crti.o and
     77                 * crtn.o are in.
     78                 */
     79                PROVIDE (_init = .);
     80                *crti.o(.init)
     81                *(.init)
     82                *crtn.o(.init)
     83                PROVIDE (_fini = .);
     84                *crti.o(.fini)
     85                *(.fini)
     86                *crtn.o(.fini)
    13187
    132     _etext = .;
    133     PROVIDE (etext = .);
    134        
    135   } >ram =0x4e75
    136  
    137   . = ALIGN (16);
    138  
    139   .data :
    140   {
    141     data_start = .;
    142    
    143     *(.data)
    144     *(.data.*)
    145     *(.data1)
    146     *(.sdata)
    147     *(.gnu.linkonce.d*)
    148     *(.gcc_except_table)
    149    
    150     . = ALIGN (16);
    151     _edata = .;
    152     PROVIDE (edata = .);
    153   } >ram
     88                /*
     89                 * C++ constructors/destructors
     90                 *
     91                 * gcc uses crtbegin.o to find the start of the constructors
     92                 * and destructors so we make sure it is first.  Because this
     93                 * is a wildcard, it doesn't matter if the user does not
     94                 * actually link against crtbegin.o; the linker won't look for
     95                 * a file to match a wildcard.  The wildcard also means that
     96                 * it doesn't matter which directory crtbegin.o is in. The
     97                 * constructor and destructor list are terminated in
     98                 * crtend.o.  The same comments apply to it.
     99                 */
     100                . = ALIGN (16);
     101                *crtbegin.o(.ctors)
     102                *(.ctors)
     103                *crtend.o(.ctors)
     104                *crtbegin.o(.dtors)
     105                *(.dtors)
     106                *crtend.o(.dtors)
    154107
    155   .bss :
    156   {
    157     bss_start = .;
    158     *(.dynbss)
    159     *(.bss)
    160     *(COMMON)
    161     *(.sbss)
    162     *(.scommon) 
    163    
    164     . = ALIGN (16);
    165     _end = .;
    166     PROVIDE (end = .);
    167   } >ram
     108                /*
     109                 * Exception frame info
     110                 */
     111                . = ALIGN (16);
     112                *(.eh_frame)
    168113
    169   _HeapStart    = .;
    170   . += HeapSize;        /* XXX -- Old gld can't handle this     */
    171   _HeapEnd = .;
    172   _StackStart = .;
    173   . += StackSize;       /* XXX -- Old gld can't handle this     */
    174   /* . +=       0x10000; */     /* HeapSize     for     old     gld     */
    175   /* . +=       0x1000;  */     /* StackSize for old gld */
    176   . =   ALIGN (16);
    177   _StackEnd = .;
    178   stack_init = .;
    179   clear_end =   .;
     114                /*
     115                 * Read-only data
     116                 */
     117                . = ALIGN (16);
     118                _rodata_start = . ;
     119                *(.rodata)
     120                *(.gnu.linkonce.r*)
    180121
    181   _WorkspaceBase        = .;
     122                 . = ALIGN (16);
     123                PROVIDE (_etext = .);
     124        } >ram
     125        .data : {
     126                PROVIDE (_copy_start = .);
     127                *(.data)
     128                *(.gnu.linkonce.d*)
     129                *(.gcc_except_table)
     130                . = ALIGN (16);
     131                PROVIDE (_edata = .);
     132                PROVIDE (_copy_end = .);
     133        } >ram
     134        .bss : {
     135                PROVIDE (_bss_start = .);
     136                PROVIDE (_clear_start = .);
     137                *(.bss)
     138                *(COMMON)
     139                . = ALIGN (16);
     140                PROVIDE (end = .);
    182141
    183   /* Stabs debugging sections.  */
    184   .stab 0 : { *(.stab) }
    185   .stabstr 0 : { *(.stabstr) }
    186   .stab.excl 0 : { *(.stab.excl) }
    187   .stab.exclstr 0 : { *(.stab.exclstr) }
    188   .stab.index 0 : { *(.stab.index) }
    189   .stab.indexstr 0 : { *(.stab.indexstr) }
    190   .comment 0 : { *(.comment) }
    191  
    192   /* DWARF debug sections.
    193      Symbols in the DWARF debugging sections are relative to the beginning
    194      of the section so we begin them at 0.  */
    195   /* DWARF 1 */
    196   .debug          0 : { *(.debug) }
    197   .line           0 : { *(.line) }
    198  
    199   /* GNU DWARF 1 extensions */
    200   .debug_srcinfo  0 : { *(.debug_srcinfo) }
    201   .debug_sfnames  0 : { *(.debug_sfnames) }
    202  
    203   /* DWARF 1.1 and DWARF 2 */
    204   .debug_aranges  0 : { *(.debug_aranges) }
    205   .debug_pubnames 0 : { *(.debug_pubnames) }
    206  
    207   /* DWARF 2 */
    208   .debug_info     0 : { *(.debug_info) }
    209   .debug_abbrev   0 : { *(.debug_abbrev) }
    210   .debug_line     0 : { *(.debug_line) }
    211   .debug_frame    0 : { *(.debug_frame) }
    212   .debug_str      0 : { *(.debug_str) }
    213   .debug_loc      0 : { *(.debug_loc) }
    214   .debug_macinfo  0 : { *(.debug_macinfo) }
    215  
    216   /* SGI/MIPS DWARF 2 extensions */
    217   .debug_weaknames 0 : { *(.debug_weaknames) }
    218   .debug_funcnames 0 : { *(.debug_funcnames) }
    219   .debug_typenames 0 : { *(.debug_typenames) }
    220   .debug_varnames  0 : { *(.debug_varnames) }
    221   /* These must appear regardless of  .  */
     142                . += StackSize;
     143                PROVIDE (_stack_init = .);
     144
     145                . = ALIGN (16);
     146                PROVIDE (_HeapStart = .);
     147                . += HeapSize;
     148                PROVIDE (_HeapEnd = .);
     149                PROVIDE (_clear_end = .);
     150
     151                PROVIDE (_WorkspaceBase = .);
     152        } >ram
    222153}
    223 
  • c/src/lib/libbsp/m68k/ods68302/bsp_specs

    r69537ca9 rb2b4835  
    1717%{!qrtems: %(old_startfile)} %{qrtems: \
    1818%{!qrtems_debug: start.o%s} \
    19 %{qrtems_debug: start_g.o%s}}
     19%{qrtems_debug: start_g.o%s} \
     20crti.o%s crtbegin.o%s}
    2021
    2122*link:
    2223%{!qrtems: %(old_link)} %{qrtems: -dc -dp -N -e start}
    2324
     25*endfile:
     26%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s crtn.o%s}
     27
  • c/src/lib/libbsp/m68k/ods68302/startup/linkcmds

    r69537ca9 rb2b4835  
    66 */
    77
     8/*
     9 * Declare some sizes.
     10 */
     11HeapSize = DEFINED(HeapSize) ? HeapSize : 0x10000;
     12StackSize = DEFINED(StackSize) ? StackSize : 0x1000;
     13
     14/*
     15 * Declare on-board memory.
     16 */
     17MEMORY {
     18          ram : ORIGIN = 0x00000000, LENGTH = 1M
     19}
    820SECTIONS
    921{
    10   .vtable 0 :
    11   {
    12     vtable_start = .;
    13     *(.vtable)
    14     evtable = .;
    15   }
     22        ram : {
     23                . = .;
     24        } >ram
    1625
    17   .text . :
    18   {
    19     text_start = .;
    20     *(.text)
    21     . = ALIGN (16);
     26        .vtable :
     27        {
     28                vtable_start = .;
     29                *(.vtable)
     30                evtable = .;
     31        } >ram
    2232
    23     *(.eh_fram)
    24     . = ALIGN (16);
    2533
    26     etext = .;
    27     . = ALIGN(4);
    28     __CTOR_LIST__ = .;
    29     LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
    30     *(.ctors)
    31     LONG(0)
    32     __CTOR_END__ = .;
    33     . = ALIGN(4);
    34     __DTOR_LIST__ = .;
    35     LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
    36     *(.dtors)
    37     LONG(0)
    38     __DTOR_END__ = .;
    39   }
    40  
    41   .data : {
    42     data_start = .;
    43     *(.data)
    44     *(.rodata)
    45     edata = .;
    46   }
    47   .bss : {
    48     bss_start = .;
    49     *(.bss)
    50     *(COMMON)
    51     end = . ;
    52     _end = . ;
    53   } 
     34        /*
     35         * Text, data and bss segments
     36         */
     37        .text : {
     38                *(.text)
     39
     40                /*
     41                 * C++ constructors/destructors
     42                 */
     43                *(.gnu.linkonce.t.*)
     44
     45                /*
     46                 * Initialization and finalization code.
     47                 *
     48                 * Various files can provide initialization and finalization
     49                 * functions.  crtbegin.o and crtend.o are two instances. The
     50                 * body of these functions are in .init and .fini sections. We
     51                 * accumulate the bodies here, and prepend function prologues
     52                 * from crti.o and function epilogues from crtn.o. crti.o must
     53                 * be linked first; crtn.o must be linked last.  Because these
     54                 * are wildcards, it doesn't matter if the user does not
     55                 * actually link against crti.o and crtn.o; the linker won't
     56                 * look for a file to match a wildcard.  The wildcard also
     57                 * means that it doesn't matter which directory crti.o and
     58                 * crtn.o are in.
     59                 */
     60                PROVIDE (_init = .);
     61                *crti.o(.init)
     62                *(.init)
     63                *crtn.o(.init)
     64                PROVIDE (_fini = .);
     65                *crti.o(.fini)
     66                *(.fini)
     67                *crtn.o(.fini)
     68
     69                /*
     70                 * C++ constructors/destructors
     71                 *
     72                 * gcc uses crtbegin.o to find the start of the constructors
     73                 * and destructors so we make sure it is first.  Because this
     74                 * is a wildcard, it doesn't matter if the user does not
     75                 * actually link against crtbegin.o; the linker won't look for
     76                 * a file to match a wildcard.  The wildcard also means that
     77                 * it doesn't matter which directory crtbegin.o is in. The
     78                 * constructor and destructor list are terminated in
     79                 * crtend.o.  The same comments apply to it.
     80                 */
     81                . = ALIGN (16);
     82                *crtbegin.o(.ctors)
     83                *(.ctors)
     84                *crtend.o(.ctors)
     85                *crtbegin.o(.dtors)
     86                *(.dtors)
     87                *crtend.o(.dtors)
     88
     89                /*
     90                 * Exception frame info
     91                 */
     92                . = ALIGN (16);
     93                *(.eh_frame)
     94
     95                /*
     96                 * Read-only data
     97                 */
     98                . = ALIGN (16);
     99                _rodata_start = . ;
     100                *(.rodata)
     101                *(.gnu.linkonce.r*)
     102
     103                 . = ALIGN (16);
     104                PROVIDE (_etext = .);
     105        } >ram
     106        .data : {
     107                PROVIDE (_copy_start = .);
     108                *(.data)
     109                *(.gnu.linkonce.d*)
     110                *(.gcc_except_table)
     111                . = ALIGN (16);
     112                PROVIDE (_edata = .);
     113                PROVIDE (_copy_end = .);
     114        } >ram
     115        .bss : {
     116                PROVIDE (_bss_start = .);
     117                PROVIDE (_clear_start = .);
     118                *(.bss)
     119                *(COMMON)
     120                . = ALIGN (16);
     121                PROVIDE (end = .);
     122
     123                . += StackSize;
     124                PROVIDE (_stack_init = .);
     125
     126                . = ALIGN (16);
     127                PROVIDE (_HeapStart = .);
     128                . += HeapSize;
     129                PROVIDE (_HeapEnd = .);
     130
     131                clear_end = .;
     132
     133                PROVIDE (_WorkspaceBase = .);
     134        } >ram
    54135}
    55136
Note: See TracChangeset for help on using the changeset viewer.