Home | History | Annotate | Download | only in ldscripts
      1 /* Script for -N: mix text and data on same page; don't align data */
      2 OUTPUT_FORMAT("elf32-tradlittlemips", "elf32-tradbigmips",
      3 	      "elf32-tradlittlemips")
      4 OUTPUT_ARCH(mips)
      5 ENTRY(__start)
      6 SECTIONS
      7 {
      8   /* Read-only sections, merged into text segment: */
      9   PROVIDE (__executable_start = 0x80000); . = 0x80000 + SIZEOF_HEADERS;
     10   .interp         : { *(.interp) }
     11   .reginfo        : { *(.reginfo) }
     12   .note.gnu.build-id : { *(.note.gnu.build-id) }
     13   .hash           : { *(.hash) }
     14   .gnu.hash       : { *(.gnu.hash) }
     15   .dynsym         : { *(.dynsym) }
     16   .dynstr         : { *(.dynstr) }
     17   .gnu.version    : { *(.gnu.version) }
     18   .gnu.version_d  : { *(.gnu.version_d) }
     19   .gnu.version_r  : { *(.gnu.version_r) }
     20   .rel.init       : { *(.rel.init) }
     21   .rela.init      : { *(.rela.init) }
     22   .rel.text       : { *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*) }
     23   .rela.text      : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
     24   .rel.fini       : { *(.rel.fini) }
     25   .rela.fini      : { *(.rela.fini) }
     26   .rel.rodata     : { *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*) }
     27   .rela.rodata    : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
     28   .rel.data.rel.ro   : { *(.rel.data.rel.ro .rel.data.rel.ro.* .rel.gnu.linkonce.d.rel.ro.*) }
     29   .rela.data.rel.ro   : { *(.rela.data.rel.ro .rela.data.rel.ro.* .rela.gnu.linkonce.d.rel.ro.*) }
     30   .rel.data       : { *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) }
     31   .rela.data      : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
     32   .rel.tdata	  : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) }
     33   .rela.tdata	  : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
     34   .rel.tbss	  : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) }
     35   .rela.tbss	  : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
     36   .rel.ctors      : { *(.rel.ctors) }
     37   .rela.ctors     : { *(.rela.ctors) }
     38   .rel.dtors      : { *(.rel.dtors) }
     39   .rela.dtors     : { *(.rela.dtors) }
     40   .rel.got        : { *(.rel.got) }
     41   .rela.got       : { *(.rela.got) }
     42   .rel.dyn        : { *(.rel.dyn) }
     43   .rel.sdata      : { *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*) }
     44   .rela.sdata     : { *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*) }
     45   .rel.sbss       : { *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*) }
     46   .rela.sbss      : { *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*) }
     47   .rel.sdata2     : { *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*) }
     48   .rela.sdata2    : { *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*) }
     49   .rel.sbss2      : { *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*) }
     50   .rela.sbss2     : { *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*) }
     51   .rel.bss        : { *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*) }
     52   .rela.bss       : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
     53   .rel.iplt       :
     54     {
     55       PROVIDE_HIDDEN (__rel_iplt_start = .);
     56       *(.rel.iplt)
     57       PROVIDE_HIDDEN (__rel_iplt_end = .);
     58     }
     59   .rela.iplt      :
     60     {
     61       PROVIDE_HIDDEN (__rela_iplt_start = .);
     62       *(.rela.iplt)
     63       PROVIDE_HIDDEN (__rela_iplt_end = .);
     64     }
     65   .rel.plt        :
     66     {
     67       *(.rel.plt)
     68     }
     69   .rela.plt       :
     70     {
     71       *(.rela.plt)
     72     }
     73   .init           :
     74   {
     75     KEEP (*(.init))
     76   }
     77   .plt            : { *(.plt) }
     78   .iplt           : { *(.iplt) }
     79   .text           :
     80   {
     81     _ftext = . ;
     82     *(.text.unlikely .text.*_unlikely)
     83     *(.text.exit .text.exit.*)
     84     *(.text.startup .text.startup.*)
     85     *(.text.hot .text.hot.*)
     86     *(.text .stub .text.* .gnu.linkonce.t.*)
     87     /* .gnu.warning sections are handled specially by elf32.em.  */
     88     *(.gnu.warning)
     89     *(.mips16.fn.*) *(.mips16.call.*)
     90   }
     91   .fini           :
     92   {
     93     KEEP (*(.fini))
     94   }
     95   PROVIDE (__etext = .);
     96   PROVIDE (_etext = .);
     97   PROVIDE (etext = .);
     98   .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
     99   .rodata1        : { *(.rodata1) }
    100   .sdata2         :
    101   {
    102     *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
    103   }
    104   .sbss2          : { *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*) }
    105   .eh_frame_hdr : { *(.eh_frame_hdr) }
    106   .eh_frame       : ONLY_IF_RO { KEEP (*(.eh_frame)) }
    107   .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table
    108   .gcc_except_table.*) }
    109   /* These sections are generated by the Sun/Oracle C++ compiler.  */
    110   .exception_ranges   : ONLY_IF_RO { *(.exception_ranges
    111   .exception_ranges*) }
    112   /* Adjust the address for the data segment.  We want to align at exactly
    113      a page boundary to make life easier for apriori. */
    114   . = .;
    115   /* Exception handling  */
    116   .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) }
    117   .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
    118   .exception_ranges   : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
    119   /* Thread Local Storage sections  */
    120   .tdata	  : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
    121   .tbss		  : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
    122   /* Ensure the __preinit_array_start label is properly aligned.  We
    123      could instead move the label definition inside the section, but
    124      the linker would then create the section even if it turns out to
    125      be empty, which isn't pretty.  */
    126   . = ALIGN(32 / 8);
    127   PROVIDE_HIDDEN (__preinit_array_start = .);
    128   .preinit_array     :
    129   {
    130     KEEP (*(.preinit_array))
    131   }
    132   PROVIDE_HIDDEN (__preinit_array_end = .);
    133   PROVIDE_HIDDEN (__init_array_start = .);
    134   .init_array     :
    135   {
    136     KEEP (*crtbegin*.o(.init_array))
    137     KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
    138     KEEP (*(.init_array))
    139     KEEP (*(EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
    140   }
    141   PROVIDE_HIDDEN (__init_array_end = .);
    142   PROVIDE_HIDDEN (__fini_array_start = .);
    143   .fini_array     :
    144   {
    145     KEEP (*crtbegin*.o(.fini_array))
    146     KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
    147     KEEP (*(.fini_array))
    148     KEEP (*(EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
    149   }
    150   PROVIDE_HIDDEN (__fini_array_end = .);
    151   .ctors          :
    152   {
    153     /* gcc uses crtbegin.o to find the start of
    154        the constructors, so we make sure it is
    155        first.  Because this is a wildcard, it
    156        doesn't matter if the user does not
    157        actually link against crtbegin.o; the
    158        linker won't look for a file to match a
    159        wildcard.  The wildcard also means that it
    160        doesn't matter which directory crtbegin.o
    161        is in.  */
    162     KEEP (*crtbegin.o(.ctors))
    163     KEEP (*crtbegin*.o(.ctors))
    164     /* We don't want to include the .ctor section from
    165        the crtend.o file until after the sorted ctors.
    166        The .ctor section from the crtend file contains the
    167        end of ctors marker and it must be last */
    168     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend*.o ) .ctors))
    169     KEEP (*(SORT(.ctors.*)))
    170     KEEP (*(.ctors))
    171   }
    172   .dtors          :
    173   {
    174     KEEP (*crtbegin.o(.dtors))
    175     KEEP (*crtbegin*.o(.dtors))
    176     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend*.o ) .dtors))
    177     KEEP (*(SORT(.dtors.*)))
    178     KEEP (*(.dtors))
    179   }
    180   .jcr            : { KEEP (*(.jcr)) }
    181   .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
    182   .dynamic        : { *(.dynamic) }
    183   .data           :
    184   {
    185     _fdata = . ;
    186     *(.data .data.* .gnu.linkonce.d.*)
    187     SORT(CONSTRUCTORS)
    188   }
    189   .data1          : { *(.data1) }
    190   .got.plt        : { *(.got.plt) }
    191   . = .;
    192   . = .;
    193   _gp = ALIGN(16) + 0x7ff0;
    194   .got            : { *(.got) }
    195   /* We want the small data sections together, so single-instruction offsets
    196      can access them all, and initialized data all before uninitialized, so
    197      we can shorten the on-disk segment size.  */
    198   .sdata          :
    199   {
    200     *(.sdata .sdata.* .gnu.linkonce.s.*)
    201   }
    202   .lit8           : { *(.lit8) }
    203   .lit4           : { *(.lit4) }
    204   _edata = .; PROVIDE (edata = .);
    205   . = .;
    206   __bss_start = .;
    207   _fbss = .;
    208   .sbss           :
    209   {
    210     *(.dynsbss)
    211     *(.sbss .sbss.* .gnu.linkonce.sb.*)
    212     *(.scommon)
    213   }
    214   .bss            :
    215   {
    216    *(.dynbss)
    217    *(.bss .bss.* .gnu.linkonce.b.*)
    218    *(COMMON)
    219    /* Align here to ensure that the .bss section occupies space up to
    220       _end.  Align after .bss to ensure correct alignment even if the
    221       .bss section disappears because there are no input sections.  */
    222    . = ALIGN(32 / 8);
    223   }
    224   . = ALIGN(32 / 8);
    225   . = ALIGN(32 / 8);
    226   _end = .;
    227   _bss_end__ = . ; __bss_end__ = . ; __end__ = . ;
    228   PROVIDE (end = .);
    229   /* Stabs debugging sections.  */
    230   .stab          0 : { *(.stab) }
    231   .stabstr       0 : { *(.stabstr) }
    232   .stab.excl     0 : { *(.stab.excl) }
    233   .stab.exclstr  0 : { *(.stab.exclstr) }
    234   .stab.index    0 : { *(.stab.index) }
    235   .stab.indexstr 0 : { *(.stab.indexstr) }
    236   .comment       0 : { *(.comment) }
    237   /* DWARF debug sections.
    238      Symbols in the DWARF debugging sections are relative to the beginning
    239      of the section so we begin them at 0.  */
    240   /* DWARF 1 */
    241   .debug          0 : { *(.debug) }
    242   .line           0 : { *(.line) }
    243   /* GNU DWARF 1 extensions */
    244   .debug_srcinfo  0 : { *(.debug_srcinfo) }
    245   .debug_sfnames  0 : { *(.debug_sfnames) }
    246   /* DWARF 1.1 and DWARF 2 */
    247   .debug_aranges  0 : { *(.debug_aranges) }
    248   .debug_pubnames 0 : { *(.debug_pubnames) }
    249   /* DWARF 2 */
    250   .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
    251   .debug_abbrev   0 : { *(.debug_abbrev) }
    252   .debug_line     0 : { *(.debug_line) }
    253   .debug_frame    0 : { *(.debug_frame) }
    254   .debug_str      0 : { *(.debug_str) }
    255   .debug_loc      0 : { *(.debug_loc) }
    256   .debug_macinfo  0 : { *(.debug_macinfo) }
    257   /* SGI/MIPS DWARF 2 extensions */
    258   .debug_weaknames 0 : { *(.debug_weaknames) }
    259   .debug_funcnames 0 : { *(.debug_funcnames) }
    260   .debug_typenames 0 : { *(.debug_typenames) }
    261   .debug_varnames  0 : { *(.debug_varnames) }
    262   /* DWARF 3 */
    263   .debug_pubtypes 0 : { *(.debug_pubtypes) }
    264   .debug_ranges   0 : { *(.debug_ranges) }
    265   /* DWARF Extension.  */
    266   .debug_macro    0 : { *(.debug_macro) }
    267   .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
    268   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }
    269   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }
    270   .gcc_compiled_long32 0 : { KEEP(*(.gcc_compiled_long32)) }
    271   .gcc_compiled_long64 0 : { KEEP(*(.gcc_compiled_long64)) }
    272   /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) *(.mdebug.*) }
    273 }
    274