mn10300 linker script update

classic Classic list List threaded Threaded
5 messages Options
Reply | Threaded
Open this post in threaded view
|

mn10300 linker script update

Jeff Law


Modern versions of the toolchain have added several new sections that
need to appear in the linker script.  Most notable are a few .bss
sections for the C++ runtime.  Failure to include these sections leads
to memory corruption as the _end symbol incorrectly appears before the
end of the .bss sections.  Needless to say this causes a variety of fun
and interesting problems as the C++ runtime clobbers the heap and
vice-versa.

I resync'd all the mn103 libgloss linker scripts with the standard
mn10300 linker script.    I've tested the simulator linker script
thoroughly, but since I don't have eval boards, I can't actually test
the others.

Given I haven't contributed to this code in nearly a decade, I thought
it best to wait for approval/feedback rather than just check in the
changes :-)

OK to apply?

 
    * libgloss/mn10300/sim.ld: Sync with standard mn10300 elf linker script.
    * libgloss/mn10300/{asb2303.ld,asb2305.ld,eval.ld}: Likewise.



? .j.ld.swp
? j.ld
Index: asb2303.ld
===================================================================
RCS file: /cvs/src/src/libgloss/mn10300/asb2303.ld,v
retrieving revision 1.2
diff -c -r1.2 asb2303.ld
*** asb2303.ld 20 May 2005 15:45:43 -0000 1.2
--- asb2303.ld 2 Sep 2008 15:25:00 -0000
***************
*** 6,122 ****
  OUTPUT_ARCH(mn10300)
  ENTRY(_start)
  GROUP(-lc -lcygmon -lgcc)
!  SEARCH_DIR(.);
  STARTUP(crt0_cygmon.o)
-
- /* Do we need any of these for elf?
-    __DYNAMIC = 0;    */
  SECTIONS
  {
    /* Read-only sections, merged into text segment: */
!   /* Start of RAM (leaving room for Cygmon data) */
!   . = 0x90080000;
!
!   .interp     : { *(.interp) }
!   .hash          : { *(.hash) }
!   .dynsym        : { *(.dynsym) }
!   .dynstr        : { *(.dynstr) }
!   .gnu.version   : { *(.gnu.version) }
!   .gnu.version_d   : { *(.gnu.version_d) }
!   .gnu.version_r   : { *(.gnu.version_r) }
!   .rel.text      :
!     { *(.rel.text) *(.rel.gnu.linkonce.t*) }
!   .rela.text     :
!     { *(.rela.text) *(.rela.gnu.linkonce.t*) }
!   .rel.data      :
!     { *(.rel.data) *(.rel.gnu.linkonce.d*) }
!   .rela.data     :
!     { *(.rela.data) *(.rela.gnu.linkonce.d*) }
!   .rel.rodata    :
!     { *(.rel.rodata) *(.rel.gnu.linkonce.r*) }
!   .rela.rodata   :
!     { *(.rela.rodata) *(.rela.gnu.linkonce.r*) }
!   .rel.got       : { *(.rel.got) }
!   .rela.got      : { *(.rela.got) }
!   .rel.ctors     : { *(.rel.ctors) }
!   .rela.ctors    : { *(.rela.ctors) }
!   .rel.dtors     : { *(.rel.dtors) }
!   .rela.dtors    : { *(.rela.dtors) }
!   .rel.init      : { *(.rel.init) }
!   .rela.init     : { *(.rela.init) }
!   .rel.fini      : { *(.rel.fini) }
!   .rela.fini     : { *(.rela.fini) }
!   .rel.bss       : { *(.rel.bss) }
!   .rela.bss      : { *(.rela.bss) }
!   .rel.plt       : { *(.rel.plt) }
!   .rela.plt      : { *(.rela.plt) }
!   .init          : { *(.init) } =0
!   .plt      : { *(.plt) }
!   .text      :
    {
!     *(.text)
      /* .gnu.warning sections are handled specially by elf32.em.  */
      *(.gnu.warning)
-     *(.gnu.linkonce.t*)
-     *(.gcc_except_table)
    } =0
!   _etext = .;
    PROVIDE (etext = .);
!   .fini      : { *(.fini)    } =0
!   .rodata    : { *(.rodata) *(.gnu.linkonce.r*) }
!   .rodata1   : { *(.rodata1) }
    /* Adjust the address for the data segment.  We want to adjust up to
       the same address within the page on the next page up.  */
    . = ALIGN(1) + (. & (1 - 1));
!   .data    :
    {
!     *(.data)
!     *(.gnu.linkonce.d*)
!     CONSTRUCTORS
    }
!   .data1   : { *(.data1) }
!   .ctors         :
    {
      ___ctors = .;
!     KEEP(*crtbegin.o(.ctors))
!     KEEP(*(SORT(.ctors.*)))
!     KEEP(*(.ctors))
      ___ctors_end = .;
    }
!   .dtors         :
    {
      ___dtors = .;
!     KEEP(*crtbegin.o(.dtors))
!     KEEP(*(SORT(.dtors.*)))
!     KEEP(*(.dtors))
      ___dtors_end = .;
    }
!   .got           : { *(.got.plt) *(.got) }
!   .dynamic       : { *(.dynamic) }
    /* We want the small data sections together, so single-instruction offsets
       can access them all, and initialized data all before uninitialized, so
       we can shorten the on-disk segment size.  */
!   .sdata     : { *(.sdata) }
!   _edata  =  .;
!   PROVIDE (edata = .);
    __bss_start = .;
!   .sbss      : { *(.sbss) *(.scommon) }
!   .bss       :
    {
     *(.dynbss)
!    *(.bss)
     *(COMMON)
    }
!   _end = . ;
!   PROVIDE (end = .);
    /* Stabs debugging sections.  */
!   .stab 0 : { *(.stab) }
!   .stabstr 0 : { *(.stabstr) }
!   .stab.excl 0 : { *(.stab.excl) }
!   .stab.exclstr 0 : { *(.stab.exclstr) }
!   .stab.index 0 : { *(.stab.index) }
    .stab.indexstr 0 : { *(.stab.indexstr) }
!   .comment 0 : { *(.comment) }
    /* DWARF debug sections.
       Symbols in the DWARF debugging sections are relative to the beginning
       of the section so we begin them at 0.  */
--- 6,199 ----
  OUTPUT_ARCH(mn10300)
  ENTRY(_start)
  GROUP(-lc -lcygmon -lgcc)
! SEARCH_DIR(.);
  STARTUP(crt0_cygmon.o)
  SECTIONS
  {
+   . = 90080000;
    /* Read-only sections, merged into text segment: */
!   PROVIDE (__executable_start = 0x0); . = 0x0;
!   .interp         : { *(.interp) }
!   .note.gnu.build-id : { *(.note.gnu.build-id) }
!   .hash           : { *(.hash) }
!   .gnu.hash       : { *(.gnu.hash) }
!   .dynsym         : { *(.dynsym) }
!   .dynstr         : { *(.dynstr) }
!   .gnu.version    : { *(.gnu.version) }
!   .gnu.version_d  : { *(.gnu.version_d) }
!   .gnu.version_r  : { *(.gnu.version_r) }
!   .rel.init       : { *(.rel.init) }
!   .rela.init      : { *(.rela.init) }
!   .rel.text       : { *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*) }
!   .rela.text      : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
!   .rel.fini       : { *(.rel.fini) }
!   .rela.fini      : { *(.rela.fini) }
!   .rel.rodata     : { *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*) }
!   .rela.rodata    : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
!   .rel.data.rel.ro   : { *(.rel.data.rel.ro* .rel.gnu.linkonce.d.rel.ro.*) }
!   .rela.data.rel.ro   : { *(.rela.data.rel.ro* .rela.gnu.linkonce.d.rel.ro.*) }
!   .rel.data       : { *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) }
!   .rela.data      : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
!   .rel.tdata  : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) }
!   .rela.tdata  : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
!   .rel.tbss  : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) }
!   .rela.tbss  : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
!   .rel.ctors      : { *(.rel.ctors) }
!   .rela.ctors     : { *(.rela.ctors) }
!   .rel.dtors      : { *(.rel.dtors) }
!   .rela.dtors     : { *(.rela.dtors) }
!   .rel.got        : { *(.rel.got) }
!   .rela.got       : { *(.rela.got) }
!   .rel.sdata      : { *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*) }
!   .rela.sdata     : { *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*) }
!   .rel.sbss       : { *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*) }
!   .rela.sbss      : { *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*) }
!   .rel.sdata2     : { *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*) }
!   .rela.sdata2    : { *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*) }
!   .rel.sbss2      : { *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*) }
!   .rela.sbss2     : { *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*) }
!   .rel.bss        : { *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*) }
!   .rela.bss       : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
!   .rel.plt        : { *(.rel.plt) }
!   .rela.plt       : { *(.rela.plt) }
!   .init           :
    {
!     KEEP (*(.init))
!   } =0
!   .plt            : { *(.plt) }
!   .text           :
!   {
!     *(.text .stub .text.* .gnu.linkonce.t.*)
      /* .gnu.warning sections are handled specially by elf32.em.  */
      *(.gnu.warning)
    } =0
!   .fini           :
!   {
!     KEEP (*(.fini))
!   } =0
!   PROVIDE (__etext = .);
!   PROVIDE (_etext = .);
    PROVIDE (etext = .);
!   .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
!   .rodata1        : { *(.rodata1) }
!   .sdata2         :
!   {
!     *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
!   }
!   .sbss2          : { *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*) }
!   .eh_frame_hdr : { *(.eh_frame_hdr) }
!   .eh_frame       : ONLY_IF_RO { KEEP (*(.eh_frame)) }
!   .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
    /* Adjust the address for the data segment.  We want to adjust up to
       the same address within the page on the next page up.  */
    . = ALIGN(1) + (. & (1 - 1));
!   /* Exception handling  */
!   .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) }
!   .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
!   /* Thread Local Storage sections  */
!   .tdata  : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
!   .tbss  : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
!   .preinit_array     :
!   {
!     PROVIDE_HIDDEN (__preinit_array_start = .);
!     KEEP (*(.preinit_array))
!     PROVIDE_HIDDEN (__preinit_array_end = .);
!   }
!   .init_array     :
!   {
!      PROVIDE_HIDDEN (__init_array_start = .);
!      KEEP (*(SORT(.init_array.*)))
!      KEEP (*(.init_array))
!      PROVIDE_HIDDEN (__init_array_end = .);
!   }
!   .fini_array     :
    {
!     PROVIDE_HIDDEN (__fini_array_start = .);
!     KEEP (*(.fini_array))
!     KEEP (*(SORT(.fini_array.*)))
!     PROVIDE_HIDDEN (__fini_array_end = .);
    }
!   .ctors          :
    {
      ___ctors = .;
!     /* gcc uses crtbegin.o to find the start of
!        the constructors, so we make sure it is
!        first.  Because this is a wildcard, it
!        doesn't matter if the user does not
!        actually link against crtbegin.o; the
!        linker won't look for a file to match a
!        wildcard.  The wildcard also means that it
!        doesn't matter which directory crtbegin.o
!        is in.  */
!     KEEP (*crtbegin.o(.ctors))
!     KEEP (*crtbegin?.o(.ctors))
!     /* We don't want to include the .ctor section from
!        the crtend.o file until after the sorted ctors.
!        The .ctor section from the crtend file contains the
!        end of ctors marker and it must be last */
!     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
!     KEEP (*(SORT(.ctors.*)))
!     KEEP (*(.ctors))
      ___ctors_end = .;
    }
!   .dtors          :
    {
      ___dtors = .;
!     KEEP (*crtbegin.o(.dtors))
!     KEEP (*crtbegin?.o(.dtors))
!     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
!     KEEP (*(SORT(.dtors.*)))
!     KEEP (*(.dtors))
      ___dtors_end = .;
    }
!   .jcr            : { KEEP (*(.jcr)) }
!   .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*) }
!   .dynamic        : { *(.dynamic) }
!   .data           :
!   {
!     *(.data .data.* .gnu.linkonce.d.*)
!     SORT(CONSTRUCTORS)
!   }
!   .data1          : { *(.data1) }
!   .got            : { *(.got.plt) *(.got) }
    /* We want the small data sections together, so single-instruction offsets
       can access them all, and initialized data all before uninitialized, so
       we can shorten the on-disk segment size.  */
!   .sdata          :
!   {
!     *(.sdata .sdata.* .gnu.linkonce.s.*)
!   }
!   _edata = .; PROVIDE (edata = .);
    __bss_start = .;
!   .sbss           :
!   {
!     *(.dynsbss)
!     *(.sbss .sbss.* .gnu.linkonce.sb.*)
!     *(.scommon)
!   }
!   .bss            :
    {
     *(.dynbss)
!    *(.bss .bss.* .gnu.linkonce.b.*)
     *(COMMON)
+    /* Align here to ensure that the .bss section occupies space up to
+       _end.  Align after .bss to ensure correct alignment even if the
+       .bss section disappears because there are no input sections.
+       FIXME: Why do we need it? When there is no .bss section, we don't
+       pad the .data section.  */
+    . = ALIGN(. != 0 ? 32 / 8 : 1);
    }
!   . = ALIGN(32 / 8);
!   . = ALIGN(32 / 8);
!   _end = .; PROVIDE (end = .);
    /* Stabs debugging sections.  */
!   .stab          0 : { *(.stab) }
!   .stabstr       0 : { *(.stabstr) }
!   .stab.excl     0 : { *(.stab.excl) }
!   .stab.exclstr  0 : { *(.stab.exclstr) }
!   .stab.index    0 : { *(.stab.index) }
    .stab.indexstr 0 : { *(.stab.indexstr) }
!   .comment       0 : { *(.comment) }
    /* DWARF debug sections.
       Symbols in the DWARF debugging sections are relative to the beginning
       of the section so we begin them at 0.  */
***************
*** 130,151 ****
    .debug_aranges  0 : { *(.debug_aranges) }
    .debug_pubnames 0 : { *(.debug_pubnames) }
    /* DWARF 2 */
!   .debug_info     0 : { *(.debug_info) }
    .debug_abbrev   0 : { *(.debug_abbrev) }
    .debug_line     0 : { *(.debug_line) }
    .debug_frame    0 : { *(.debug_frame) }
    .debug_str      0 : { *(.debug_str) }
    .debug_loc      0 : { *(.debug_loc) }
    .debug_macinfo  0 : { *(.debug_macinfo) }
-   .debug_ranges   0 : { *(.debug_ranges) }
    /* SGI/MIPS DWARF 2 extensions */
    .debug_weaknames 0 : { *(.debug_weaknames) }
    .debug_funcnames 0 : { *(.debug_funcnames) }
    .debug_typenames 0 : { *(.debug_typenames) }
    .debug_varnames  0 : { *(.debug_varnames) }
!
!    /* Top of RAM is 0x48100000, but Cygmon uses the top 4K for its stack.  */
!   .stack 0x480ff000 : { _stack = .; *(.stack) *(._stack) }
!
!   /* These must appear regardless of  .  */
  }
--- 207,234 ----
    .debug_aranges  0 : { *(.debug_aranges) }
    .debug_pubnames 0 : { *(.debug_pubnames) }
    /* DWARF 2 */
!   .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
    .debug_abbrev   0 : { *(.debug_abbrev) }
    .debug_line     0 : { *(.debug_line) }
    .debug_frame    0 : { *(.debug_frame) }
    .debug_str      0 : { *(.debug_str) }
    .debug_loc      0 : { *(.debug_loc) }
    .debug_macinfo  0 : { *(.debug_macinfo) }
    /* SGI/MIPS DWARF 2 extensions */
    .debug_weaknames 0 : { *(.debug_weaknames) }
    .debug_funcnames 0 : { *(.debug_funcnames) }
    .debug_typenames 0 : { *(.debug_typenames) }
    .debug_varnames  0 : { *(.debug_varnames) }
!   /* DWARF 3 */
!   .debug_pubtypes 0 : { *(.debug_pubtypes) }
!   .debug_ranges   0 : { *(.debug_ranges) }
!     /* Top of RAM is 0x48100000, but Cygmon uses the top 4K for its stack.  */
!    .stack         0x480ff000 :
!   {
!     _stack = .;
!     *(.stack)
!     *(._stack)
!   }
!   .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
!   /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) }
  }
Index: asb2305.ld
===================================================================
RCS file: /cvs/src/src/libgloss/mn10300/asb2305.ld,v
retrieving revision 1.2
diff -c -r1.2 asb2305.ld
*** asb2305.ld 20 May 2005 15:45:43 -0000 1.2
--- asb2305.ld 2 Sep 2008 15:25:00 -0000
***************
*** 6,122 ****
  OUTPUT_ARCH(am33-2)
  ENTRY(_start)
  GROUP(-lc -lcygmon -lgcc)
-  SEARCH_DIR(.);
  STARTUP(crt0_redboot.o)
!
! /* Do we need any of these for elf?
!    __DYNAMIC = 0;    */
  SECTIONS
  {
    /* Read-only sections, merged into text segment: */
!   /* Start of RAM (leaving room for RedBoot data) */
!   . = 0x90700000;
!
!   .interp     : { *(.interp) }
!   .hash          : { *(.hash) }
!   .dynsym        : { *(.dynsym) }
!   .dynstr        : { *(.dynstr) }
!   .gnu.version   : { *(.gnu.version) }
!   .gnu.version_d   : { *(.gnu.version_d) }
!   .gnu.version_r   : { *(.gnu.version_r) }
!   .rel.text      :
!     { *(.rel.text) *(.rel.gnu.linkonce.t*) }
!   .rela.text     :
!     { *(.rela.text) *(.rela.gnu.linkonce.t*) }
!   .rel.data      :
!     { *(.rel.data) *(.rel.gnu.linkonce.d*) }
!   .rela.data     :
!     { *(.rela.data) *(.rela.gnu.linkonce.d*) }
!   .rel.rodata    :
!     { *(.rel.rodata) *(.rel.gnu.linkonce.r*) }
!   .rela.rodata   :
!     { *(.rela.rodata) *(.rela.gnu.linkonce.r*) }
!   .rel.got       : { *(.rel.got) }
!   .rela.got      : { *(.rela.got) }
!   .rel.ctors     : { *(.rel.ctors) }
!   .rela.ctors    : { *(.rela.ctors) }
!   .rel.dtors     : { *(.rel.dtors) }
!   .rela.dtors    : { *(.rela.dtors) }
!   .rel.init      : { *(.rel.init) }
!   .rela.init     : { *(.rela.init) }
!   .rel.fini      : { *(.rel.fini) }
!   .rela.fini     : { *(.rela.fini) }
!   .rel.bss       : { *(.rel.bss) }
!   .rela.bss      : { *(.rela.bss) }
!   .rel.plt       : { *(.rel.plt) }
!   .rela.plt      : { *(.rela.plt) }
!   .init          : { *(.init) } =0
!   .plt      : { *(.plt) }
!   .text      :
    {
!     *(.text)
      /* .gnu.warning sections are handled specially by elf32.em.  */
      *(.gnu.warning)
-     *(.gnu.linkonce.t*)
-     *(.gcc_except_table)
    } =0
!   _etext = .;
    PROVIDE (etext = .);
!   .fini      : { *(.fini)    } =0
!   .rodata    : { *(.rodata) *(.gnu.linkonce.r*) }
!   .rodata1   : { *(.rodata1) }
    /* Adjust the address for the data segment.  We want to adjust up to
       the same address within the page on the next page up.  */
    . = ALIGN(1) + (. & (1 - 1));
!   .data    :
    {
!     *(.data)
!     *(.gnu.linkonce.d*)
!     CONSTRUCTORS
    }
!   .data1   : { *(.data1) }
!   .ctors         :
    {
      ___ctors = .;
!     KEEP(*crtbegin.o(.ctors))
!     KEEP(*(SORT(.ctors.*)))
!     KEEP(*(.ctors))
      ___ctors_end = .;
    }
!   .dtors         :
    {
      ___dtors = .;
!     KEEP(*crtbegin.o(.dtors))
!     KEEP(*(SORT(.dtors.*)))
!     KEEP(*(.dtors))
      ___dtors_end = .;
    }
!   .got           : { *(.got.plt) *(.got) }
!   .dynamic       : { *(.dynamic) }
    /* We want the small data sections together, so single-instruction offsets
       can access them all, and initialized data all before uninitialized, so
       we can shorten the on-disk segment size.  */
!   .sdata     : { *(.sdata) }
!   _edata  =  .;
!   PROVIDE (edata = .);
    __bss_start = .;
!   .sbss      : { *(.sbss) *(.scommon) }
!   .bss       :
    {
     *(.dynbss)
!    *(.bss)
     *(COMMON)
    }
!   _end = . ;
!   PROVIDE (end = .);
    /* Stabs debugging sections.  */
!   .stab 0 : { *(.stab) }
!   .stabstr 0 : { *(.stabstr) }
!   .stab.excl 0 : { *(.stab.excl) }
!   .stab.exclstr 0 : { *(.stab.exclstr) }
!   .stab.index 0 : { *(.stab.index) }
    .stab.indexstr 0 : { *(.stab.indexstr) }
!   .comment 0 : { *(.comment) }
    /* DWARF debug sections.
       Symbols in the DWARF debugging sections are relative to the beginning
       of the section so we begin them at 0.  */
--- 6,199 ----
  OUTPUT_ARCH(am33-2)
  ENTRY(_start)
  GROUP(-lc -lcygmon -lgcc)
  STARTUP(crt0_redboot.o)
! SEARCH_DIR(.);
  SECTIONS
  {
+   . = 90700000;
    /* Read-only sections, merged into text segment: */
!   PROVIDE (__executable_start = 0x0); . = 0x0;
!   .interp         : { *(.interp) }
!   .note.gnu.build-id : { *(.note.gnu.build-id) }
!   .hash           : { *(.hash) }
!   .gnu.hash       : { *(.gnu.hash) }
!   .dynsym         : { *(.dynsym) }
!   .dynstr         : { *(.dynstr) }
!   .gnu.version    : { *(.gnu.version) }
!   .gnu.version_d  : { *(.gnu.version_d) }
!   .gnu.version_r  : { *(.gnu.version_r) }
!   .rel.init       : { *(.rel.init) }
!   .rela.init      : { *(.rela.init) }
!   .rel.text       : { *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*) }
!   .rela.text      : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
!   .rel.fini       : { *(.rel.fini) }
!   .rela.fini      : { *(.rela.fini) }
!   .rel.rodata     : { *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*) }
!   .rela.rodata    : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
!   .rel.data.rel.ro   : { *(.rel.data.rel.ro* .rel.gnu.linkonce.d.rel.ro.*) }
!   .rela.data.rel.ro   : { *(.rela.data.rel.ro* .rela.gnu.linkonce.d.rel.ro.*) }
!   .rel.data       : { *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) }
!   .rela.data      : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
!   .rel.tdata  : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) }
!   .rela.tdata  : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
!   .rel.tbss  : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) }
!   .rela.tbss  : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
!   .rel.ctors      : { *(.rel.ctors) }
!   .rela.ctors     : { *(.rela.ctors) }
!   .rel.dtors      : { *(.rel.dtors) }
!   .rela.dtors     : { *(.rela.dtors) }
!   .rel.got        : { *(.rel.got) }
!   .rela.got       : { *(.rela.got) }
!   .rel.sdata      : { *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*) }
!   .rela.sdata     : { *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*) }
!   .rel.sbss       : { *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*) }
!   .rela.sbss      : { *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*) }
!   .rel.sdata2     : { *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*) }
!   .rela.sdata2    : { *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*) }
!   .rel.sbss2      : { *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*) }
!   .rela.sbss2     : { *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*) }
!   .rel.bss        : { *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*) }
!   .rela.bss       : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
!   .rel.plt        : { *(.rel.plt) }
!   .rela.plt       : { *(.rela.plt) }
!   .init           :
    {
!     KEEP (*(.init))
!   } =0
!   .plt            : { *(.plt) }
!   .text           :
!   {
!     *(.text .stub .text.* .gnu.linkonce.t.*)
      /* .gnu.warning sections are handled specially by elf32.em.  */
      *(.gnu.warning)
    } =0
!   .fini           :
!   {
!     KEEP (*(.fini))
!   } =0
!   PROVIDE (__etext = .);
!   PROVIDE (_etext = .);
    PROVIDE (etext = .);
!   .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
!   .rodata1        : { *(.rodata1) }
!   .sdata2         :
!   {
!     *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
!   }
!   .sbss2          : { *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*) }
!   .eh_frame_hdr : { *(.eh_frame_hdr) }
!   .eh_frame       : ONLY_IF_RO { KEEP (*(.eh_frame)) }
!   .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
    /* Adjust the address for the data segment.  We want to adjust up to
       the same address within the page on the next page up.  */
    . = ALIGN(1) + (. & (1 - 1));
!   /* Exception handling  */
!   .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) }
!   .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
!   /* Thread Local Storage sections  */
!   .tdata  : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
!   .tbss  : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
!   .preinit_array     :
!   {
!     PROVIDE_HIDDEN (__preinit_array_start = .);
!     KEEP (*(.preinit_array))
!     PROVIDE_HIDDEN (__preinit_array_end = .);
!   }
!   .init_array     :
!   {
!      PROVIDE_HIDDEN (__init_array_start = .);
!      KEEP (*(SORT(.init_array.*)))
!      KEEP (*(.init_array))
!      PROVIDE_HIDDEN (__init_array_end = .);
!   }
!   .fini_array     :
    {
!     PROVIDE_HIDDEN (__fini_array_start = .);
!     KEEP (*(.fini_array))
!     KEEP (*(SORT(.fini_array.*)))
!     PROVIDE_HIDDEN (__fini_array_end = .);
    }
!   .ctors          :
    {
      ___ctors = .;
!     /* gcc uses crtbegin.o to find the start of
!        the constructors, so we make sure it is
!        first.  Because this is a wildcard, it
!        doesn't matter if the user does not
!        actually link against crtbegin.o; the
!        linker won't look for a file to match a
!        wildcard.  The wildcard also means that it
!        doesn't matter which directory crtbegin.o
!        is in.  */
!     KEEP (*crtbegin.o(.ctors))
!     KEEP (*crtbegin?.o(.ctors))
!     /* We don't want to include the .ctor section from
!        the crtend.o file until after the sorted ctors.
!        The .ctor section from the crtend file contains the
!        end of ctors marker and it must be last */
!     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
!     KEEP (*(SORT(.ctors.*)))
!     KEEP (*(.ctors))
      ___ctors_end = .;
    }
!   .dtors          :
    {
      ___dtors = .;
!     KEEP (*crtbegin.o(.dtors))
!     KEEP (*crtbegin?.o(.dtors))
!     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
!     KEEP (*(SORT(.dtors.*)))
!     KEEP (*(.dtors))
      ___dtors_end = .;
    }
!   .jcr            : { KEEP (*(.jcr)) }
!   .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*) }
!   .dynamic        : { *(.dynamic) }
!   .data           :
!   {
!     *(.data .data.* .gnu.linkonce.d.*)
!     SORT(CONSTRUCTORS)
!   }
!   .data1          : { *(.data1) }
!   .got            : { *(.got.plt) *(.got) }
    /* We want the small data sections together, so single-instruction offsets
       can access them all, and initialized data all before uninitialized, so
       we can shorten the on-disk segment size.  */
!   .sdata          :
!   {
!     *(.sdata .sdata.* .gnu.linkonce.s.*)
!   }
!   _edata = .; PROVIDE (edata = .);
    __bss_start = .;
!   .sbss           :
!   {
!     *(.dynsbss)
!     *(.sbss .sbss.* .gnu.linkonce.sb.*)
!     *(.scommon)
!   }
!   .bss            :
    {
     *(.dynbss)
!    *(.bss .bss.* .gnu.linkonce.b.*)
     *(COMMON)
+    /* Align here to ensure that the .bss section occupies space up to
+       _end.  Align after .bss to ensure correct alignment even if the
+       .bss section disappears because there are no input sections.
+       FIXME: Why do we need it? When there is no .bss section, we don't
+       pad the .data section.  */
+    . = ALIGN(. != 0 ? 32 / 8 : 1);
    }
!   . = ALIGN(32 / 8);
!   . = ALIGN(32 / 8);
!   _end = .; PROVIDE (end = .);
    /* Stabs debugging sections.  */
!   .stab          0 : { *(.stab) }
!   .stabstr       0 : { *(.stabstr) }
!   .stab.excl     0 : { *(.stab.excl) }
!   .stab.exclstr  0 : { *(.stab.exclstr) }
!   .stab.index    0 : { *(.stab.index) }
    .stab.indexstr 0 : { *(.stab.indexstr) }
!   .comment       0 : { *(.comment) }
    /* DWARF debug sections.
       Symbols in the DWARF debugging sections are relative to the beginning
       of the section so we begin them at 0.  */
***************
*** 130,151 ****
    .debug_aranges  0 : { *(.debug_aranges) }
    .debug_pubnames 0 : { *(.debug_pubnames) }
    /* DWARF 2 */
!   .debug_info     0 : { *(.debug_info) }
    .debug_abbrev   0 : { *(.debug_abbrev) }
    .debug_line     0 : { *(.debug_line) }
    .debug_frame    0 : { *(.debug_frame) }
    .debug_str      0 : { *(.debug_str) }
    .debug_loc      0 : { *(.debug_loc) }
    .debug_macinfo  0 : { *(.debug_macinfo) }
-   .debug_ranges   0 : { *(.debug_ranges) }
    /* SGI/MIPS DWARF 2 extensions */
    .debug_weaknames 0 : { *(.debug_weaknames) }
    .debug_funcnames 0 : { *(.debug_funcnames) }
    .debug_typenames 0 : { *(.debug_typenames) }
    .debug_varnames  0 : { *(.debug_varnames) }
!
!    /* Top of usable RAM is 0x91000000  */
!   .stack 0x91000000 : { _stack = .; *(.stack) *(._stack) }
!
!   /* These must appear regardless of  .  */
  }
--- 207,233 ----
    .debug_aranges  0 : { *(.debug_aranges) }
    .debug_pubnames 0 : { *(.debug_pubnames) }
    /* DWARF 2 */
!   .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
    .debug_abbrev   0 : { *(.debug_abbrev) }
    .debug_line     0 : { *(.debug_line) }
    .debug_frame    0 : { *(.debug_frame) }
    .debug_str      0 : { *(.debug_str) }
    .debug_loc      0 : { *(.debug_loc) }
    .debug_macinfo  0 : { *(.debug_macinfo) }
    /* SGI/MIPS DWARF 2 extensions */
    .debug_weaknames 0 : { *(.debug_weaknames) }
    .debug_funcnames 0 : { *(.debug_funcnames) }
    .debug_typenames 0 : { *(.debug_typenames) }
    .debug_varnames  0 : { *(.debug_varnames) }
!   /* DWARF 3 */
!   .debug_pubtypes 0 : { *(.debug_pubtypes) }
!   .debug_ranges   0 : { *(.debug_ranges) }
!     .stack         0x91000000  :
!   {
!     _stack = .;
!     *(.stack)
!     *(._stack)
!   }
!   .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
!   /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) }
  }
Index: eval.ld
===================================================================
RCS file: /cvs/src/src/libgloss/mn10300/eval.ld,v
retrieving revision 1.2
diff -c -r1.2 eval.ld
*** eval.ld 20 May 2005 15:45:43 -0000 1.2
--- eval.ld 2 Sep 2008 15:25:00 -0000
***************
*** 8,122 ****
  OUTPUT_ARCH(mn10300)
  ENTRY(_start)
  GROUP(-lc -leval -lgcc)
!  SEARCH_DIR(.);
! /* Do we need any of these for elf?
!    __DYNAMIC = 0;    */
  SECTIONS
  {
    /* Read-only sections, merged into text segment: */
!   /* Start of RAM (leaving room for Cygmon data) */
!   . = 0x48008000;
!
!   .interp     : { *(.interp) }
!   .hash          : { *(.hash) }
!   .dynsym        : { *(.dynsym) }
!   .dynstr        : { *(.dynstr) }
!   .gnu.version   : { *(.gnu.version) }
!   .gnu.version_d   : { *(.gnu.version_d) }
!   .gnu.version_r   : { *(.gnu.version_r) }
!   .rel.text      :
!     { *(.rel.text) *(.rel.gnu.linkonce.t*) }
!   .rela.text     :
!     { *(.rela.text) *(.rela.gnu.linkonce.t*) }
!   .rel.data      :
!     { *(.rel.data) *(.rel.gnu.linkonce.d*) }
!   .rela.data     :
!     { *(.rela.data) *(.rela.gnu.linkonce.d*) }
!   .rel.rodata    :
!     { *(.rel.rodata) *(.rel.gnu.linkonce.r*) }
!   .rela.rodata   :
!     { *(.rela.rodata) *(.rela.gnu.linkonce.r*) }
!   .rel.got       : { *(.rel.got) }
!   .rela.got      : { *(.rela.got) }
!   .rel.ctors     : { *(.rel.ctors) }
!   .rela.ctors    : { *(.rela.ctors) }
!   .rel.dtors     : { *(.rel.dtors) }
!   .rela.dtors    : { *(.rela.dtors) }
!   .rel.init      : { *(.rel.init) }
!   .rela.init     : { *(.rela.init) }
!   .rel.fini      : { *(.rel.fini) }
!   .rela.fini     : { *(.rela.fini) }
!   .rel.bss       : { *(.rel.bss) }
!   .rela.bss      : { *(.rela.bss) }
!   .rel.plt       : { *(.rel.plt) }
!   .rela.plt      : { *(.rela.plt) }
!   .init          : { *(.init) } =0
!   .plt      : { *(.plt) }
!   .text      :
    {
!     *(.text)
      /* .gnu.warning sections are handled specially by elf32.em.  */
      *(.gnu.warning)
-     *(.gnu.linkonce.t*)
-     *(.gcc_except_table)
    } =0
!   _etext = .;
    PROVIDE (etext = .);
!   .fini      : { *(.fini)    } =0
!   .rodata    : { *(.rodata) *(.gnu.linkonce.r*) }
!   .rodata1   : { *(.rodata1) }
    /* Adjust the address for the data segment.  We want to adjust up to
       the same address within the page on the next page up.  */
    . = ALIGN(1) + (. & (1 - 1));
!   .data    :
    {
!     *(.data)
!     *(.gnu.linkonce.d*)
!     CONSTRUCTORS
    }
!   .data1   : { *(.data1) }
!   .ctors         :
    {
      ___ctors = .;
!     KEEP(*crtbegin.o(.ctors))
!     KEEP(*(SORT(.ctors.*)))
!     KEEP(*(.ctors))
      ___ctors_end = .;
    }
!   .dtors         :
    {
      ___dtors = .;
!     KEEP(*crtbegin.o(.dtors))
!     KEEP(*(SORT(.dtors.*)))
!     KEEP(*(.dtors))
      ___dtors_end = .;
    }
!   .got           : { *(.got.plt) *(.got) }
!   .dynamic       : { *(.dynamic) }
    /* We want the small data sections together, so single-instruction offsets
       can access them all, and initialized data all before uninitialized, so
       we can shorten the on-disk segment size.  */
!   .sdata     : { *(.sdata) }
!   _edata  =  .;
!   PROVIDE (edata = .);
    __bss_start = .;
!   .sbss      : { *(.sbss) *(.scommon) }
!   .bss       :
    {
     *(.dynbss)
!    *(.bss)
     *(COMMON)
    }
!   _end = . ;
!   PROVIDE (end = .);
    /* Stabs debugging sections.  */
!   .stab 0 : { *(.stab) }
!   .stabstr 0 : { *(.stabstr) }
!   .stab.excl 0 : { *(.stab.excl) }
!   .stab.exclstr 0 : { *(.stab.exclstr) }
!   .stab.index 0 : { *(.stab.index) }
    .stab.indexstr 0 : { *(.stab.indexstr) }
!   .comment 0 : { *(.comment) }
    /* DWARF debug sections.
       Symbols in the DWARF debugging sections are relative to the beginning
       of the section so we begin them at 0.  */
--- 8,200 ----
  OUTPUT_ARCH(mn10300)
  ENTRY(_start)
  GROUP(-lc -leval -lgcc)
! SEARCH_DIR(.);
  SECTIONS
  {
+   . = 48008000;
    /* Read-only sections, merged into text segment: */
!   PROVIDE (__executable_start = 0x0); . = 0x0;
!   .interp         : { *(.interp) }
!   .note.gnu.build-id : { *(.note.gnu.build-id) }
!   .hash           : { *(.hash) }
!   .gnu.hash       : { *(.gnu.hash) }
!   .dynsym         : { *(.dynsym) }
!   .dynstr         : { *(.dynstr) }
!   .gnu.version    : { *(.gnu.version) }
!   .gnu.version_d  : { *(.gnu.version_d) }
!   .gnu.version_r  : { *(.gnu.version_r) }
!   .rel.init       : { *(.rel.init) }
!   .rela.init      : { *(.rela.init) }
!   .rel.text       : { *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*) }
!   .rela.text      : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
!   .rel.fini       : { *(.rel.fini) }
!   .rela.fini      : { *(.rela.fini) }
!   .rel.rodata     : { *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*) }
!   .rela.rodata    : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
!   .rel.data.rel.ro   : { *(.rel.data.rel.ro* .rel.gnu.linkonce.d.rel.ro.*) }
!   .rela.data.rel.ro   : { *(.rela.data.rel.ro* .rela.gnu.linkonce.d.rel.ro.*) }
!   .rel.data       : { *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) }
!   .rela.data      : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
!   .rel.tdata  : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) }
!   .rela.tdata  : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
!   .rel.tbss  : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) }
!   .rela.tbss  : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
!   .rel.ctors      : { *(.rel.ctors) }
!   .rela.ctors     : { *(.rela.ctors) }
!   .rel.dtors      : { *(.rel.dtors) }
!   .rela.dtors     : { *(.rela.dtors) }
!   .rel.got        : { *(.rel.got) }
!   .rela.got       : { *(.rela.got) }
!   .rel.sdata      : { *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*) }
!   .rela.sdata     : { *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*) }
!   .rel.sbss       : { *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*) }
!   .rela.sbss      : { *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*) }
!   .rel.sdata2     : { *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*) }
!   .rela.sdata2    : { *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*) }
!   .rel.sbss2      : { *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*) }
!   .rela.sbss2     : { *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*) }
!   .rel.bss        : { *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*) }
!   .rela.bss       : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
!   .rel.plt        : { *(.rel.plt) }
!   .rela.plt       : { *(.rela.plt) }
!   .init           :
    {
!     KEEP (*(.init))
!   } =0
!   .plt            : { *(.plt) }
!   .text           :
!   {
!     *(.text .stub .text.* .gnu.linkonce.t.*)
      /* .gnu.warning sections are handled specially by elf32.em.  */
      *(.gnu.warning)
    } =0
!   .fini           :
!   {
!     KEEP (*(.fini))
!   } =0
!   PROVIDE (__etext = .);
!   PROVIDE (_etext = .);
    PROVIDE (etext = .);
!   .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
!   .rodata1        : { *(.rodata1) }
!   .sdata2         :
!   {
!     *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
!   }
!   .sbss2          : { *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*) }
!   .eh_frame_hdr : { *(.eh_frame_hdr) }
!   .eh_frame       : ONLY_IF_RO { KEEP (*(.eh_frame)) }
!   .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
    /* Adjust the address for the data segment.  We want to adjust up to
       the same address within the page on the next page up.  */
    . = ALIGN(1) + (. & (1 - 1));
!   /* Exception handling  */
!   .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) }
!   .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
!   /* Thread Local Storage sections  */
!   .tdata  : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
!   .tbss  : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
!   .preinit_array     :
!   {
!     PROVIDE_HIDDEN (__preinit_array_start = .);
!     KEEP (*(.preinit_array))
!     PROVIDE_HIDDEN (__preinit_array_end = .);
!   }
!   .init_array     :
!   {
!      PROVIDE_HIDDEN (__init_array_start = .);
!      KEEP (*(SORT(.init_array.*)))
!      KEEP (*(.init_array))
!      PROVIDE_HIDDEN (__init_array_end = .);
!   }
!   .fini_array     :
    {
!     PROVIDE_HIDDEN (__fini_array_start = .);
!     KEEP (*(.fini_array))
!     KEEP (*(SORT(.fini_array.*)))
!     PROVIDE_HIDDEN (__fini_array_end = .);
    }
!   .ctors          :
    {
      ___ctors = .;
!     /* gcc uses crtbegin.o to find the start of
!        the constructors, so we make sure it is
!        first.  Because this is a wildcard, it
!        doesn't matter if the user does not
!        actually link against crtbegin.o; the
!        linker won't look for a file to match a
!        wildcard.  The wildcard also means that it
!        doesn't matter which directory crtbegin.o
!        is in.  */
!     KEEP (*crtbegin.o(.ctors))
!     KEEP (*crtbegin?.o(.ctors))
!     /* We don't want to include the .ctor section from
!        the crtend.o file until after the sorted ctors.
!        The .ctor section from the crtend file contains the
!        end of ctors marker and it must be last */
!     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
!     KEEP (*(SORT(.ctors.*)))
!     KEEP (*(.ctors))
      ___ctors_end = .;
    }
!   .dtors          :
    {
      ___dtors = .;
!     KEEP (*crtbegin.o(.dtors))
!     KEEP (*crtbegin?.o(.dtors))
!     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
!     KEEP (*(SORT(.dtors.*)))
!     KEEP (*(.dtors))
      ___dtors_end = .;
    }
!   .jcr            : { KEEP (*(.jcr)) }
!   .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*) }
!   .dynamic        : { *(.dynamic) }
!   .data           :
!   {
!     *(.data .data.* .gnu.linkonce.d.*)
!     SORT(CONSTRUCTORS)
!   }
!   .data1          : { *(.data1) }
!   .got            : { *(.got.plt) *(.got) }
    /* We want the small data sections together, so single-instruction offsets
       can access them all, and initialized data all before uninitialized, so
       we can shorten the on-disk segment size.  */
!   .sdata          :
!   {
!     *(.sdata .sdata.* .gnu.linkonce.s.*)
!   }
!   _edata = .; PROVIDE (edata = .);
    __bss_start = .;
!   .sbss           :
!   {
!     *(.dynsbss)
!     *(.sbss .sbss.* .gnu.linkonce.sb.*)
!     *(.scommon)
!   }
!   .bss            :
    {
     *(.dynbss)
!    *(.bss .bss.* .gnu.linkonce.b.*)
     *(COMMON)
+    /* Align here to ensure that the .bss section occupies space up to
+       _end.  Align after .bss to ensure correct alignment even if the
+       .bss section disappears because there are no input sections.
+       FIXME: Why do we need it? When there is no .bss section, we don't
+       pad the .data section.  */
+    . = ALIGN(. != 0 ? 32 / 8 : 1);
    }
!   . = ALIGN(32 / 8);
!   . = ALIGN(32 / 8);
!   _end = .; PROVIDE (end = .);
    /* Stabs debugging sections.  */
!   .stab          0 : { *(.stab) }
!   .stabstr       0 : { *(.stabstr) }
!   .stab.excl     0 : { *(.stab.excl) }
!   .stab.exclstr  0 : { *(.stab.exclstr) }
!   .stab.index    0 : { *(.stab.index) }
    .stab.indexstr 0 : { *(.stab.indexstr) }
!   .comment       0 : { *(.comment) }
    /* DWARF debug sections.
       Symbols in the DWARF debugging sections are relative to the beginning
       of the section so we begin them at 0.  */
***************
*** 130,151 ****
    .debug_aranges  0 : { *(.debug_aranges) }
    .debug_pubnames 0 : { *(.debug_pubnames) }
    /* DWARF 2 */
!   .debug_info     0 : { *(.debug_info) }
    .debug_abbrev   0 : { *(.debug_abbrev) }
    .debug_line     0 : { *(.debug_line) }
    .debug_frame    0 : { *(.debug_frame) }
    .debug_str      0 : { *(.debug_str) }
    .debug_loc      0 : { *(.debug_loc) }
    .debug_macinfo  0 : { *(.debug_macinfo) }
-   .debug_ranges   0 : { *(.debug_ranges) }
    /* SGI/MIPS DWARF 2 extensions */
    .debug_weaknames 0 : { *(.debug_weaknames) }
    .debug_funcnames 0 : { *(.debug_funcnames) }
    .debug_typenames 0 : { *(.debug_typenames) }
    .debug_varnames  0 : { *(.debug_varnames) }
!
!    /* Top of RAM is 0x48100000, but Cygmon uses the top 4K for its stack.  */
!   .stack 0x480ff000 : { _stack = .; *(.stack) *(._stack) }
!
!   /* These must appear regardless of  .  */
  }
--- 208,235 ----
    .debug_aranges  0 : { *(.debug_aranges) }
    .debug_pubnames 0 : { *(.debug_pubnames) }
    /* DWARF 2 */
!   .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
    .debug_abbrev   0 : { *(.debug_abbrev) }
    .debug_line     0 : { *(.debug_line) }
    .debug_frame    0 : { *(.debug_frame) }
    .debug_str      0 : { *(.debug_str) }
    .debug_loc      0 : { *(.debug_loc) }
    .debug_macinfo  0 : { *(.debug_macinfo) }
    /* SGI/MIPS DWARF 2 extensions */
    .debug_weaknames 0 : { *(.debug_weaknames) }
    .debug_funcnames 0 : { *(.debug_funcnames) }
    .debug_typenames 0 : { *(.debug_typenames) }
    .debug_varnames  0 : { *(.debug_varnames) }
!   /* DWARF 3 */
!   .debug_pubtypes 0 : { *(.debug_pubtypes) }
!   .debug_ranges   0 : { *(.debug_ranges) }
!   /* Top of RAM is 0x48100000, but Cygmon uses the top 4K for its stack.  */
!   .stack         0x480ff000 :
!   {
!     _stack = .;
!     *(.stack)
!     *(._stack)
!   }
!   .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
!   /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) }
  }
Index: sim.ld
===================================================================
RCS file: /cvs/src/src/libgloss/mn10300/sim.ld,v
retrieving revision 1.3
diff -c -r1.3 sim.ld
*** sim.ld 20 May 2005 15:45:43 -0000 1.3
--- sim.ld 2 Sep 2008 15:25:00 -0000
***************
*** 6,120 ****
  OUTPUT_ARCH(mn10300)
  ENTRY(_start)
  GROUP(-lc -leval -lgcc)
!  SEARCH_DIR(.);
! /* Do we need any of these for elf?
!    __DYNAMIC = 0;    */
  SECTIONS
  {
-   /* Read-only sections, merged into text segment: */
-   /* Start of RAM (leaving room for Cygmon data) */
    . = 4;
!
!   .interp     : { *(.interp) }
!   .hash          : { *(.hash) }
!   .dynsym        : { *(.dynsym) }
!   .dynstr        : { *(.dynstr) }
!   .gnu.version   : { *(.gnu.version) }
!   .gnu.version_d   : { *(.gnu.version_d) }
!   .gnu.version_r   : { *(.gnu.version_r) }
!   .rel.text      :
!     { *(.rel.text) *(.rel.gnu.linkonce.t*) }
!   .rela.text     :
!     { *(.rela.text) *(.rela.gnu.linkonce.t*) }
!   .rel.data      :
!     { *(.rel.data) *(.rel.gnu.linkonce.d*) }
!   .rela.data     :
!     { *(.rela.data) *(.rela.gnu.linkonce.d*) }
!   .rel.rodata    :
!     { *(.rel.rodata) *(.rel.gnu.linkonce.r*) }
!   .rela.rodata   :
!     { *(.rela.rodata) *(.rela.gnu.linkonce.r*) }
!   .rel.got       : { *(.rel.got) }
!   .rela.got      : { *(.rela.got) }
!   .rel.ctors     : { *(.rel.ctors) }
!   .rela.ctors    : { *(.rela.ctors) }
!   .rel.dtors     : { *(.rel.dtors) }
!   .rela.dtors    : { *(.rela.dtors) }
!   .rel.init      : { *(.rel.init) }
!   .rela.init     : { *(.rela.init) }
!   .rel.fini      : { *(.rel.fini) }
!   .rela.fini     : { *(.rela.fini) }
!   .rel.bss       : { *(.rel.bss) }
!   .rela.bss      : { *(.rela.bss) }
!   .rel.plt       : { *(.rel.plt) }
!   .rela.plt      : { *(.rela.plt) }
!   .init          : { *(.init) } =0
!   .plt      : { *(.plt) }
!   .text      :
    {
!     *(.text)
      /* .gnu.warning sections are handled specially by elf32.em.  */
      *(.gnu.warning)
-     *(.gnu.linkonce.t*)
-     *(.gcc_except_table)
    } =0
!   _etext = .;
    PROVIDE (etext = .);
!   .fini      : { *(.fini)    } =0
!   .rodata    : { *(.rodata) *(.gnu.linkonce.r*) }
!   .rodata1   : { *(.rodata1) }
    /* Adjust the address for the data segment.  We want to adjust up to
       the same address within the page on the next page up.  */
    . = ALIGN(1) + (. & (1 - 1));
!   .data    :
    {
!     *(.data)
!     *(.gnu.linkonce.d*)
!     CONSTRUCTORS
    }
!   .data1   : { *(.data1) }
!   .ctors         :
    {
      ___ctors = .;
!     KEEP(*crtbegin.o(.ctors))
!     KEEP(*(SORT(.ctors.*)))
!     KEEP(*(.ctors))
      ___ctors_end = .;
    }
!   .dtors         :
    {
      ___dtors = .;
!     KEEP(*crtbegin.o(.dtors))
!     KEEP(*(SORT(.dtors.*)))
!     KEEP(*(.dtors))
      ___dtors_end = .;
    }
!   .got           : { *(.got.plt) *(.got) }
!   .dynamic       : { *(.dynamic) }
    /* We want the small data sections together, so single-instruction offsets
       can access them all, and initialized data all before uninitialized, so
       we can shorten the on-disk segment size.  */
!   .sdata     : { *(.sdata) }
!   _edata  =  .;
!   PROVIDE (edata = .);
    __bss_start = .;
!   .sbss      : { *(.sbss) *(.scommon) }
!   .bss       :
    {
     *(.dynbss)
!    *(.bss)
     *(COMMON)
    }
!   _end = . ;
!   PROVIDE (end = .);
    /* Stabs debugging sections.  */
!   .stab 0 : { *(.stab) }
!   .stabstr 0 : { *(.stabstr) }
!   .stab.excl 0 : { *(.stab.excl) }
!   .stab.exclstr 0 : { *(.stab.exclstr) }
!   .stab.index 0 : { *(.stab.index) }
    .stab.indexstr 0 : { *(.stab.indexstr) }
!   .comment 0 : { *(.comment) }
    /* DWARF debug sections.
       Symbols in the DWARF debugging sections are relative to the beginning
       of the section so we begin them at 0.  */
--- 6,198 ----
  OUTPUT_ARCH(mn10300)
  ENTRY(_start)
  GROUP(-lc -leval -lgcc)
! SEARCH_DIR(.);
  SECTIONS
  {
    . = 4;
!   /* Read-only sections, merged into text segment: */
!   PROVIDE (__executable_start = 0x0); . = 0x0;
!   .interp         : { *(.interp) }
!   .note.gnu.build-id : { *(.note.gnu.build-id) }
!   .hash           : { *(.hash) }
!   .gnu.hash       : { *(.gnu.hash) }
!   .dynsym         : { *(.dynsym) }
!   .dynstr         : { *(.dynstr) }
!   .gnu.version    : { *(.gnu.version) }
!   .gnu.version_d  : { *(.gnu.version_d) }
!   .gnu.version_r  : { *(.gnu.version_r) }
!   .rel.init       : { *(.rel.init) }
!   .rela.init      : { *(.rela.init) }
!   .rel.text       : { *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*) }
!   .rela.text      : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
!   .rel.fini       : { *(.rel.fini) }
!   .rela.fini      : { *(.rela.fini) }
!   .rel.rodata     : { *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*) }
!   .rela.rodata    : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
!   .rel.data.rel.ro   : { *(.rel.data.rel.ro* .rel.gnu.linkonce.d.rel.ro.*) }
!   .rela.data.rel.ro   : { *(.rela.data.rel.ro* .rela.gnu.linkonce.d.rel.ro.*) }
!   .rel.data       : { *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) }
!   .rela.data      : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
!   .rel.tdata  : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) }
!   .rela.tdata  : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
!   .rel.tbss  : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) }
!   .rela.tbss  : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
!   .rel.ctors      : { *(.rel.ctors) }
!   .rela.ctors     : { *(.rela.ctors) }
!   .rel.dtors      : { *(.rel.dtors) }
!   .rela.dtors     : { *(.rela.dtors) }
!   .rel.got        : { *(.rel.got) }
!   .rela.got       : { *(.rela.got) }
!   .rel.sdata      : { *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*) }
!   .rela.sdata     : { *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*) }
!   .rel.sbss       : { *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*) }
!   .rela.sbss      : { *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*) }
!   .rel.sdata2     : { *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*) }
!   .rela.sdata2    : { *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*) }
!   .rel.sbss2      : { *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*) }
!   .rela.sbss2     : { *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*) }
!   .rel.bss        : { *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*) }
!   .rela.bss       : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
!   .rel.plt        : { *(.rel.plt) }
!   .rela.plt       : { *(.rela.plt) }
!   .init           :
!   {
!     KEEP (*(.init))
!   } =0
!   .plt            : { *(.plt) }
!   .text           :
    {
!     *(.text .stub .text.* .gnu.linkonce.t.*)
      /* .gnu.warning sections are handled specially by elf32.em.  */
      *(.gnu.warning)
    } =0
!   .fini           :
!   {
!     KEEP (*(.fini))
!   } =0
!   PROVIDE (__etext = .);
!   PROVIDE (_etext = .);
    PROVIDE (etext = .);
!   .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
!   .rodata1        : { *(.rodata1) }
!   .sdata2         :
!   {
!     *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
!   }
!   .sbss2          : { *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*) }
!   .eh_frame_hdr : { *(.eh_frame_hdr) }
!   .eh_frame       : ONLY_IF_RO { KEEP (*(.eh_frame)) }
!   .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
    /* Adjust the address for the data segment.  We want to adjust up to
       the same address within the page on the next page up.  */
    . = ALIGN(1) + (. & (1 - 1));
!   /* Exception handling  */
!   .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) }
!   .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
!   /* Thread Local Storage sections  */
!   .tdata  : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
!   .tbss  : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
!   .preinit_array     :
!   {
!     PROVIDE_HIDDEN (__preinit_array_start = .);
!     KEEP (*(.preinit_array))
!     PROVIDE_HIDDEN (__preinit_array_end = .);
!   }
!   .init_array     :
!   {
!      PROVIDE_HIDDEN (__init_array_start = .);
!      KEEP (*(SORT(.init_array.*)))
!      KEEP (*(.init_array))
!      PROVIDE_HIDDEN (__init_array_end = .);
!   }
!   .fini_array     :
    {
!     PROVIDE_HIDDEN (__fini_array_start = .);
!     KEEP (*(.fini_array))
!     KEEP (*(SORT(.fini_array.*)))
!     PROVIDE_HIDDEN (__fini_array_end = .);
    }
!   .ctors          :
    {
      ___ctors = .;
!     /* gcc uses crtbegin.o to find the start of
!        the constructors, so we make sure it is
!        first.  Because this is a wildcard, it
!        doesn't matter if the user does not
!        actually link against crtbegin.o; the
!        linker won't look for a file to match a
!        wildcard.  The wildcard also means that it
!        doesn't matter which directory crtbegin.o
!        is in.  */
!     KEEP (*crtbegin.o(.ctors))
!     KEEP (*crtbegin?.o(.ctors))
!     /* We don't want to include the .ctor section from
!        the crtend.o file until after the sorted ctors.
!        The .ctor section from the crtend file contains the
!        end of ctors marker and it must be last */
!     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
!     KEEP (*(SORT(.ctors.*)))
!     KEEP (*(.ctors))
      ___ctors_end = .;
    }
!   .dtors          :
    {
      ___dtors = .;
!     KEEP (*crtbegin.o(.dtors))
!     KEEP (*crtbegin?.o(.dtors))
!     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
!     KEEP (*(SORT(.dtors.*)))
!     KEEP (*(.dtors))
      ___dtors_end = .;
    }
!   .jcr            : { KEEP (*(.jcr)) }
!   .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro* .gnu.linkonce.d.rel.ro.*) }
!   .dynamic        : { *(.dynamic) }
!   .data           :
!   {
!     *(.data .data.* .gnu.linkonce.d.*)
!     SORT(CONSTRUCTORS)
!   }
!   .data1          : { *(.data1) }
!   .got            : { *(.got.plt) *(.got) }
    /* We want the small data sections together, so single-instruction offsets
       can access them all, and initialized data all before uninitialized, so
       we can shorten the on-disk segment size.  */
!   .sdata          :
!   {
!     *(.sdata .sdata.* .gnu.linkonce.s.*)
!   }
!   _edata = .; PROVIDE (edata = .);
    __bss_start = .;
!   .sbss           :
!   {
!     *(.dynsbss)
!     *(.sbss .sbss.* .gnu.linkonce.sb.*)
!     *(.scommon)
!   }
!   .bss            :
    {
     *(.dynbss)
!    *(.bss .bss.* .gnu.linkonce.b.*)
     *(COMMON)
+    /* Align here to ensure that the .bss section occupies space up to
+       _end.  Align after .bss to ensure correct alignment even if the
+       .bss section disappears because there are no input sections.
+       FIXME: Why do we need it? When there is no .bss section, we don't
+       pad the .data section.  */
+    . = ALIGN(. != 0 ? 32 / 8 : 1);
    }
!   . = ALIGN(32 / 8);
!   . = ALIGN(32 / 8);
!   _end = .; PROVIDE (end = .);
    /* Stabs debugging sections.  */
!   .stab          0 : { *(.stab) }
!   .stabstr       0 : { *(.stabstr) }
!   .stab.excl     0 : { *(.stab.excl) }
!   .stab.exclstr  0 : { *(.stab.exclstr) }
!   .stab.index    0 : { *(.stab.index) }
    .stab.indexstr 0 : { *(.stab.indexstr) }
!   .comment       0 : { *(.comment) }
    /* DWARF debug sections.
       Symbols in the DWARF debugging sections are relative to the beginning
       of the section so we begin them at 0.  */
***************
*** 128,148 ****
    .debug_aranges  0 : { *(.debug_aranges) }
    .debug_pubnames 0 : { *(.debug_pubnames) }
    /* DWARF 2 */
!   .debug_info     0 : { *(.debug_info) }
    .debug_abbrev   0 : { *(.debug_abbrev) }
    .debug_line     0 : { *(.debug_line) }
    .debug_frame    0 : { *(.debug_frame) }
    .debug_str      0 : { *(.debug_str) }
    .debug_loc      0 : { *(.debug_loc) }
    .debug_macinfo  0 : { *(.debug_macinfo) }
-   .debug_ranges   0 : { *(.debug_ranges) }
    /* SGI/MIPS DWARF 2 extensions */
    .debug_weaknames 0 : { *(.debug_weaknames) }
    .debug_funcnames 0 : { *(.debug_funcnames) }
    .debug_typenames 0 : { *(.debug_typenames) }
    .debug_varnames  0 : { *(.debug_varnames) }
!
!   .stack 0x80000 : { _stack = .; *(.stack) *(._stack) }
!
!   /* These must appear regardless of  .  */
  }
--- 206,231 ----
    .debug_aranges  0 : { *(.debug_aranges) }
    .debug_pubnames 0 : { *(.debug_pubnames) }
    /* DWARF 2 */
!   .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
    .debug_abbrev   0 : { *(.debug_abbrev) }
    .debug_line     0 : { *(.debug_line) }
    .debug_frame    0 : { *(.debug_frame) }
    .debug_str      0 : { *(.debug_str) }
    .debug_loc      0 : { *(.debug_loc) }
    .debug_macinfo  0 : { *(.debug_macinfo) }
    /* SGI/MIPS DWARF 2 extensions */
    .debug_weaknames 0 : { *(.debug_weaknames) }
    .debug_funcnames 0 : { *(.debug_funcnames) }
    .debug_typenames 0 : { *(.debug_typenames) }
    .debug_varnames  0 : { *(.debug_varnames) }
!   /* DWARF 3 */
!   .debug_pubtypes 0 : { *(.debug_pubtypes) }
!   .debug_ranges   0 : { *(.debug_ranges) }
!     .stack         0x80000 :
!   {
!     _stack = .;
!     *(.stack)
!   }
!   .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
!   /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) }
  }
Reply | Threaded
Open this post in threaded view
|

Re: mn10300 linker script update

Jeff Johnston
Jeff Law wrote:

>
>
> Modern versions of the toolchain have added several new sections that
> need to appear in the linker script.  Most notable are a few .bss
> sections for the C++ runtime.  Failure to include these sections leads
> to memory corruption as the _end symbol incorrectly appears before the
> end of the .bss sections.  Needless to say this causes a variety of
> fun and interesting problems as the C++ runtime clobbers the heap and
> vice-versa.
>
> I resync'd all the mn103 libgloss linker scripts with the standard
> mn10300 linker script.    I've tested the simulator linker script
> thoroughly, but since I don't have eval boards, I can't actually test
> the others.
>
> Given I haven't contributed to this code in nearly a decade, I thought
> it best to wait for approval/feedback rather than just check in the
> changes :-)
>
> OK to apply?
>
Yes, please go ahead.  I assume there will be other neglected platforms
that will also be missing this change.

Thanks,

-- Jeff J.
>
>    * libgloss/mn10300/sim.ld: Sync with standard mn10300 elf linker
> script.
>    * libgloss/mn10300/{asb2303.ld,asb2305.ld,eval.ld}: Likewise.
>
>

Reply | Threaded
Open this post in threaded view
|

Re: mn10300 linker script update

Jeff Law
Jeff Johnston wrote:

> Jeff Law wrote:
>>
>>
>> Modern versions of the toolchain have added several new sections that
>> need to appear in the linker script.  Most notable are a few .bss
>> sections for the C++ runtime.  Failure to include these sections
>> leads to memory corruption as the _end symbol incorrectly appears
>> before the end of the .bss sections.  Needless to say this causes a
>> variety of fun and interesting problems as the C++ runtime clobbers
>> the heap and vice-versa.
>>
>> I resync'd all the mn103 libgloss linker scripts with the standard
>> mn10300 linker script.    I've tested the simulator linker script
>> thoroughly, but since I don't have eval boards, I can't actually test
>> the others.
>>
>> Given I haven't contributed to this code in nearly a decade, I
>> thought it best to wait for approval/feedback rather than just check
>> in the changes :-)
>>
>> OK to apply?
>>
> Yes, please go ahead.  I assume there will be other neglected
> platforms that will also be missing this change.
Most likely.   However, some don't have modern GCC toolchains so it's
not a major problem (mn102 comes to mind) and others we traditionally
haven't supported C++ (H8/300 IIRC).   However, I will make an effort to
update targets as I come across them in my testing.

Arguably at least some of these scripts could be integrated into ld's
scheme for building scripts from the basic ELF templates since they
usually just vary in a few addresses and the GROUP statements.  But I'm
not sure I want to try and tackle that yet.


Jeff
Reply | Threaded
Open this post in threaded view
|

Re: mn10300 linker script update

Duane Ellis-3
 >> Arguably at least some of these scripts could be integrated into
ld's scheme for building scripts
 >> from the basic ELF templates since they usually just vary in a few
addresses and the GROUP
 >> statements.  But I'm not sure I want to try and tackle that yet.

Yes, I know this is more of an "ld" comment - but... anyway...

I sure would like to know about "ld's scheme for building scripts" -
where can I find that type of info.

I've never found it in any of the LD docs, info or man pages.

Maybe things have changed more recently.

Why do I ask: I live in an 'embedded world'.

I've had to deal with problems like these:

For example - in some consumer electronic stuff I did we had:

Deep Sleep
    Some I have some code that lives in "on chip sram" and is safe
during 'power off' (deep battery sleep) we killed power to the SDRAM and
then rescaned the ELF when I kill power to the SDRAM chip - I reload it
when power is restored. or you "cache line lock" data into your 16K on
chip I and D cache during sleep.

Shallow Sleep
    Set the sdram in 'mobile-sdram-backup-mode' and go to sleep only a
portion of the sdram is maintained. The rest suffers bit rot and fades away.

The Deep & Shallow sleep are some what easy
    You arrange your ELF file correctly - then your ELF loader has 2 modes.
    (1) load everything, or (2) skip the parts that are in the "good" area.

In micro controllers -
   there are some chunks of code that must be "ram-functions" - commonly
flash reprogramming code
   Or something that must run with 0 wait states.

In specialized DSPs -
   Like blackfin that has (fast) L1 ram, and (slower) L2 ram, and off
chip (more slower) SDRAM, and other off chip (utterly slow) NOR flash
and so on.
   Even more weird - the dual core stuff.

I have had no end of fun with LD scripts - and I still find them
confusing.  They are often "non-trivial"

And yes, I would like to know about "ld's scheme for building scripts".

-Duane.

Reply | Threaded
Open this post in threaded view
|

Re: mn10300 linker script update

Jeff Law
Duane Ellis wrote:

> >> Arguably at least some of these scripts could be integrated into
> ld's scheme for building scripts
> >> from the basic ELF templates since they usually just vary in a few
> addresses and the GROUP
> >> statements.  But I'm not sure I want to try and tackle that yet.
>
> Yes, I know this is more of an "ld" comment - but... anyway...
>
> I sure would like to know about "ld's scheme for building scripts" -
> where can I find that type of info.
>
> I've never found it in any of the LD docs, info or man pages.
It's part of the build process for ld itself -- it has the ability to
parameterize standard linker scripts to deal with a small number of
common target differences.

The standard elf script is ld/scripttempl/elf.sc and it has a number of
parameters that can be set to build scripts which are customized for the
target.  And example of customization is ld/emulpararms/mn10300.sh.

When building the linker from source it will build a set of standard
linker scripts using the template and parameter files suitable for the
target system.

Now having said that, I don't think it's likely to resolve any of the
issues you're raising as they require defining new output memory regions
and more importantly what input sections should be placed in those
regions.    Typically what I would recommend would be to take the
standard linker script for your target and add the output sections
specific for your part to that linker script.

Jeff