"Fossies" - the Fresh Open Source Software Archive

Member "cygwin-snapshot-20190819-1/libgloss/mt/16-003.ld" (12 Jan 2016, 10025 Bytes) of package /windows/misc/cygwin-20190819-src-x86.tar.xz:


As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file.

    1 OUTPUT_FORMAT("elf32-mt", "elf32-mt", "elf32-mt")
    2 OUTPUT_ARCH(mt)
    3 ENTRY(__boot_start)
    4 
    5 /* Do we need any of these for elf?
    6    __DYNAMIC = 0;    */
    7 MEMORY
    8 {
    9   ram (rwx) : ORIGIN = 0x0, LENGTH = 608K
   10   frame-buffer (w) : ORIGIN = 0xff000000, LENGTH = 80K
   11   dma-ram (w) : ORIGIN = 0x1000000, LENGTH = 16M-4K
   12   ports (w) : ORIGIN = 0xfffff000, LENGTH = 4K
   13 }
   14 SECTIONS
   15 {
   16   /* Read-only sections, merged into text segment: */
   17   . = 0x0;
   18   PROVIDE(__executable_start = 0x0);
   19   .interp         : { *(.interp) }
   20   .hash           : { *(.hash) }
   21   .dynsym         : { *(.dynsym) }
   22   .dynstr         : { *(.dynstr) }
   23   .gnu.version    : { *(.gnu.version) }
   24   .gnu.version_d  : { *(.gnu.version_d) }
   25   .gnu.version_r  : { *(.gnu.version_r) }
   26   .rel.init       : { *(.rel.init) }
   27   .rela.init      : { *(.rela.init) }
   28   .rel.text       : { *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*) }
   29   .rela.text      : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
   30   .rel.fini       : { *(.rel.fini) }
   31   .rela.fini      : { *(.rela.fini) }
   32   .rel.rodata     : { *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*) }
   33   .rela.rodata    : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
   34   .rel.data.rel.ro  : { *(.rel.data.rel.ro*) }
   35   .rela.data.rel.ro : { *(.rela.data.rel.ro*) }
   36   .rel.data       : { *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) }
   37   .rela.data      : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
   38   .rel.tdata      : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) }
   39   .rela.tdata     : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
   40   .rel.tbss       : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) }
   41   .rela.tbss      : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
   42   .rel.ctors      : { *(.rel.ctors) }
   43   .rela.ctors     : { *(.rela.ctors) }
   44   .rel.dtors      : { *(.rel.dtors) }
   45   .rela.dtors     : { *(.rela.dtors) }
   46   .rel.got        : { *(.rel.got) }
   47   .rela.got       : { *(.rela.got) }
   48   .rel.sdata      : { *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*) }
   49   .rela.sdata     : { *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*) }
   50   .rel.sbss       : { *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*) }
   51   .rela.sbss      : { *(.rela.sbss .rela.sbss.* .rel.gnu.linkonce.sb.*) }
   52   .rel.sdata2     : { *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*) }
   53   .rela.sdata2    : { *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*) }
   54   .rel.sbss2      : { *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*) }
   55   .rela.sbss2     : { *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*) }
   56   .rel.bss        : { *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*) }
   57   .rela.bss       : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
   58   .rel.plt        : { *(.rel.plt) }
   59   .rela.plt       : { *(.rela.plt) }
   60 
   61   .startup        : { *startup-16-003.o(.startup) } >ram =0
   62   . = 0x40;
   63 
   64   .init           : { KEEP (*(.init)) } >ram =0
   65   .plt            : { *(.plt) } >ram
   66   .text           :
   67   {
   68     *startup-16-003.o(.text);
   69     *(.text .stub .text.* .gnu.linkonce.t.*)
   70     KEEP (*(.text.*personality*))
   71     /* .gnu.warning sections are handled specially by elf32.em.  */
   72     *(.gnu.warning)
   73   } >ram =0
   74   .fini           : { KEEP (*(.fini)) } >ram =0
   75   PROVIDE (__etext = .);
   76   PROVIDE (_etext = .);
   77   PROVIDE (etext = .);
   78   .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) } >ram
   79   .rodata1        : { *(.rodata1) } >ram
   80   .sdata2         : { *(.sdata2 .sdata2.* .gnu.linkonce.s2.*) } >ram
   81   .sbss2          : { *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*) } >ram
   82   .eh_frame_hdr   : { *(.eh_frame_hdr) } >ram
   83   .eh_frame       : ONLY_IF_RO { KEEP (*(.eh_frame)) } >ram
   84   .gcc_except_table : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) } >ram
   85   /* Adjust the address for the data segment.  We want to adjust up to
   86      the same address within the page on the next page up.  */
   87   . = ALIGN(256) + (. & (256 - 1));
   88   /* Exception handling  */
   89   .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) } >ram
   90   .gcc_except_table   : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) } >ram
   91   /* Thread Local Storage sections  */
   92   .tdata          : { *(.tdata .tdata.* .gnu.linkonce.td.*) } >ram
   93   .tbss           : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } >ram
   94   /* Ensure the __preinit_array_start label is properly aligned.  We
   95      could instead move the label definition inside the section, but
   96      the linker would then create the section even if it turns out to
   97      be empty, which isn't pretty.  */
   98   . = ALIGN(32 / 8);
   99   PROVIDE (__preinit_array_start = .);
  100   .preinit_array  : { *(.preinit_array) } >ram
  101   PROVIDE (__preinit_array_end = .);
  102   PROVIDE (__init_array_start = .);
  103   .init_array     : { *(.init_array) } >ram
  104   PROVIDE (__init_array_end = .);
  105   PROVIDE (__fini_array_start = .);
  106   .fini_array     : { *(.fini_array) } >ram
  107   PROVIDE (__fini_array_end = .);
  108   .ctors          :
  109   {
  110     /* gcc uses crtbegin.o to find the start of
  111        the constructors, so we make sure it is
  112        first.  Because this is a wildcard, it
  113        doesn't matter if the user does not
  114        actually link against crtbegin.o; the
  115        linker won't look for a file to match a
  116        wildcard.  The wildcard also means that it
  117        doesn't matter which directory crtbegin.o
  118        is in.  */
  119     KEEP (*crtbegin.o(.ctors))
  120     /* We don't want to include the .ctor section from
  121        from the crtend.o file until after the sorted ctors.
  122        The .ctor section from the crtend file contains the
  123        end of ctors marker and it must be last */
  124     KEEP (*(EXCLUDE_FILE (*crtend*.o ) .ctors))
  125     KEEP (*(SORT(.ctors.*)))
  126     KEEP (*(.ctors))
  127   } >ram
  128   .dtors          :
  129   {
  130     KEEP (*crtbegin*.o(.dtors))
  131     KEEP (*(EXCLUDE_FILE (*crtend*.o ) .dtors))
  132     KEEP (*(SORT(.dtors.*)))
  133     KEEP (*(.dtors))
  134   } >ram
  135   .jcr            : { KEEP (*(.jcr)) } >ram
  136   .data.rel.ro    : { *(.data.rel.ro.local) *(.data.rel.ro*) } >ram
  137   .dynamic        : { *(.dynamic) } >ram
  138 
  139   /* DJK - Re-align the data section from the read-only section. */
  140   . = ALIGN(16) + (. & (16 - 1));
  141   PROVIDE (_data = .);
  142   .data           :
  143   {
  144     *(.data .data.* .gnu.linkonce.d.*)
  145     KEEP (*(.gnu.linkonce.d.*personality*))
  146     SORT(CONSTRUCTORS)
  147   } >ram
  148   .data1          : { *(.data1) } >ram
  149   .got            : { *(.got.plt) *(.got) } >ram
  150 
  151   /* We want the small data sections together, so single-instruction offsets
  152      can access them all, and initialized data all before uninitialized, so
  153      we can shorten the on-disk segment size.  */
  154   .sdata          : { *(.sdata .sdata.* .gnu.linkonce.s.*) } >ram
  155   _edata = .;
  156   PROVIDE ( edata = . );
  157   .sbss           :
  158   {
  159     PROVIDE (__sbss_start = .);
  160     PROVIDE (___sbss_start = .);
  161     *(.dynsbss)
  162     *(.sbss .sbss.* .gnu.linkonce.sb.*)
  163     *(.scommon)
  164     PROVIDE (__sbss_end = .);
  165     PROVIDE (___sbss_end = .);
  166   } >ram
  167   .bss            :
  168   {
  169     *(.dynbss)
  170     *(.bss .bss.* .gnu.linkonce.b.*)
  171     *(COMMON)
  172     /* Align here to ensure that the .bss section occupies space up to
  173        _end.  Align after .bss to ensure correct alignment even if the
  174       .bss section disappears because there are no input sections.  */
  175     . = ALIGN(32 / 8);
  176   } >ram
  177   . = ALIGN(32 / 8);
  178   __bss_start = ADDR ( .sbss ) ;
  179   __bss_end = __bss_start + SIZEOF ( .sbss ) + SIZEOF ( .bss ) - 4 ;
  180   _end = .;
  181   PROVIDE (end = .);
  182 
  183   /* DJK - Initialized frame buffer data is copied from RAM to FB. */
  184   .auxbss         : AT (ADDR(.bss) + SIZEOF(.bss)) { *(.auxbss) } >frame-buffer
  185   .auxdata        : AT (LOADADDR(.auxbss) + SIZEOF(.auxbss))
  186   {
  187     *(.auxdata.bank0)
  188     . = ALIGN(0x4000);
  189     *(.auxdata.bank1)
  190     . = ALIGN(0x4000);
  191     *(.auxdata.bank2)
  192     . = ALIGN(0x4000);
  193     *(.auxdata.bank3)
  194     . = ALIGN(0x4000);
  195     *(.auxdata.bank4)
  196     *(.auxdata)
  197   } >frame-buffer
  198 
  199   _fbbss_start = ADDR ( .auxbss );
  200   _fbbss_end = _fbbss_start + SIZEOF ( .auxbss ) - 4;
  201   _fbdata_start = LOADADDR ( .auxdata );
  202   _fbdata_end = _fbdata_start + SIZEOF ( .auxdata ) ;
  203   _fbdata_vma = ADDR ( .auxdata );
  204   
  205   PROVIDE (__FRAME_BUFFER_START = ADDR(.auxbss) );
  206   PROVIDE (__FRAME_BUFFER_SIZE = 0x14000);
  207   PROVIDE (__FRAME_BUFFER_END = __FRAME_BUFFER_START + __FRAME_BUFFER_SIZE);
  208 
  209   .dma            : { _dma_start = .; *(.dma) _dma_end = .; } >dma-ram
  210   .internal_io (NOLOAD) : { *(.internal_io) } >ports
  211 
  212   /* Stabs debugging sections.  */
  213   .stab            0 : { *(.stab) }
  214   .stabstr         0 : { *(.stabstr) }
  215   .stab.excl       0 : { *(.stab.excl) }
  216   .stab.exclstr    0 : { *(.stab.exclstr) }
  217   .stab.index      0 : { *(.stab.index) }
  218   .stab.indexstr   0 : { *(.stab.indexstr) }
  219   .comment         0 : { *(.comment) }
  220   /* DWARF debug sections.
  221      Symbols in the DWARF debugging sections are relative to the beginning
  222      of the section so we begin them at 0.  */
  223   /* DWARF 1 */
  224   .debug           0 : { *(.debug) }
  225   .line            0 : { *(.line) }
  226   /* GNU DWARF 1 extensions */
  227   .debug_srcinfo   0 : { *(.debug_srcinfo) }
  228   .debug_sfnames   0 : { *(.debug_sfnames) }
  229   /* DWARF 1.1 and DWARF 2 */
  230   .debug_aranges   0 : { *(.debug_aranges) }
  231   .debug_pubnames  0 : { *(.debug_pubnames) }
  232   /* DWARF 2 */
  233   .debug_info      0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }
  234   .debug_abbrev    0 : { *(.debug_abbrev) }
  235   .debug_line      0 : { *(.debug_line) }
  236   .debug_frame     0 : { *(.debug_frame) }
  237   .debug_str       0 : { *(.debug_str) }
  238   .debug_loc       0 : { *(.debug_loc) }
  239   .debug_macinfo   0 : { *(.debug_macinfo) }
  240   /* SGI/MIPS DWARF 2 extensions */
  241   .debug_weaknames 0 : { *(.debug_weaknames) }
  242   .debug_funcnames 0 : { *(.debug_funcnames) }
  243   .debug_typenames 0 : { *(.debug_typenames) }
  244   .debug_varnames  0 : { *(.debug_varnames) }
  245 
  246   /* In a multi-core environment, each core is given its own stack space
  247      equal to __stack_size, growing downwards. */
  248   PROVIDE (__stack = 0x97ff0);
  249   PROVIDE (__stack_size = 0x800);
  250 
  251   .stack (DEFINED(__stack) ? __stack : 0x007ffff0) :
  252   {
  253      __stack = .;
  254     *(.stack)
  255     LONG(0xdeaddead)
  256   }
  257   /DISCARD/ : { *(.note.GNU-stack) }
  258 }