ld/scripttempl/elfd10v.sc

   1 test -z "$ENTRY" && ENTRY=_start
   2 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
   3 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
   4 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
   5 test "$LD_FLAG" = "N" && DATA_ADDR=.
   6 INTERP=".interp   ${RELOCATING-0} : { *(.interp)        }"
   7 PLT=".plt    ${RELOCATING-0} : { *(.plt)        }"
   8
   9
  10 CTOR=".ctors ${CONSTRUCTING-0} :
  11   {
  12     ${CONSTRUCTING+${CTOR_START}}
  13     /* gcc uses crtbegin.o to find the start of
  14        the constructors, so we make sure it is
  15        first.  Because this is a wildcard, it
  16        doesn't matter if the user does not
  17        actually link against crtbegin.o; the
  18        linker won't look for a file to match a
  19        wildcard.  The wildcard also means that it
  20        doesn't matter which directory crtbegin.o
  21        is in.  */
  22
  23     KEEP (*crtbegin.o(.ctors))
  24
  25     /* We don't want to include the .ctor section from
  26        from the crtend.o file until after the sorted ctors.
  27        The .ctor section from the crtend file contains the
  28        end of ctors marker and it must be last */
  29
  30     KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors))
  31     KEEP (*(SORT(.ctors.*)))
  32     KEEP (*(.ctors))
  33     ${CONSTRUCTING+${CTOR_END}}
  34   }"
  35
  36 DTOR=" .dtors       ${CONSTRUCTING-0} :
  37   {
  38     ${CONSTRUCTING+${DTOR_START}}
  39     KEEP (*crtbegin.o(.dtors))
  40     KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors))
  41     KEEP (*(SORT(.dtors.*)))
  42     KEEP (*(.dtors))
  43     ${CONSTRUCTING+${DTOR_END}}
  44   }"
  45
  46 STACK=" .stack : { _stack = .; *(.stack) } >STACK "
  47
  48 # if this is for an embedded system, don't add SIZEOF_HEADERS.
  49 if [ -z "$EMBEDDED" ]; then
  50    test -z "${READONLY_BASE_ADDRESS}" && READONLY_BASE_ADDRESS="${READONLY_START_ADDR} + SIZEOF_HEADERS"
  51 else
  52    test -z "${READONLY_BASE_ADDRESS}" && READONLY_BASE_ADDRESS="${READONLY_START_ADDR}"
  53 fi
  54
  55 cat <<EOF
  56 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
  57               "${LITTLE_OUTPUT_FORMAT}")
  58 OUTPUT_ARCH(${OUTPUT_ARCH})
  59 ENTRY(${ENTRY})
  60
  61 ${RELOCATING+${LIB_SEARCH_DIRS}}
  62 ${RELOCATING+/* Do we need any of these for elf?
  63    __DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}}  */}
  64 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
  65
  66 MEMORY
  67 {
  68   UNIFIED : org = 0,         len = 0x1000000
  69   INSN    : org = 0x1000000, len = 0x40000
  70   DATA    : org = 0x2000004, len = 0x7FFC
  71   STACK   : org = 0x2007FFE, len = 4
  72 }
  73
  74 SECTIONS
  75 {
  76   .text :
  77   {
  78     ${RELOCATING+${TEXT_START_SYMBOLS}}
  79     KEEP (*(.init))
  80     KEEP (*(.fini))
  81     *(.text)
  82     *(.text.*)
  83     /* .gnu.warning sections are handled specially by elf32.em.  */
  84     *(.gnu.warning)
  85     *(.gnu.linkonce.t*)
  86     ${RELOCATING+_etext = .;}
  87     ${RELOCATING+PROVIDE (etext = .);}
  88   } ${RELOCATING+ >INSN} =${NOP-0}
  89
  90   .rodata  ${RELOCATING-0} : {
  91     *(.rodata) *(.gnu.linkonce.r*)
  92   } ${RELOCATING+ >DATA}
  93   .rodata1 ${RELOCATING-0} : { *(.rodata1) } ${RELOCATING+ >DATA}
  94
  95   .data  ${RELOCATING-0} :
  96   {
  97     ${RELOCATING+${DATA_START_SYMBOLS}}
  98     *(.data)
  99     *(.data.*)
 100     *(.gnu.linkonce.d*)
 101     ${CONSTRUCTING+CONSTRUCTORS}
 102   } ${RELOCATING+ >DATA}
 103   .data1 ${RELOCATING-0} : { *(.data1) } ${RELOCATING+ >DATA}
 104   ${RELOCATING+${CTOR} >DATA}
 105   ${RELOCATING+${DTOR} >DATA}
 106
 107   /* We want the small data sections together, so single-instruction offsets
 108      can access them all, and initialized data all before uninitialized, so
 109      we can shorten the on-disk segment size.  */
 110   .sdata   ${RELOCATING-0} : { *(.sdata) } ${RELOCATING+ >DATA}
 111   ${RELOCATING+_edata = .;}
 112   ${RELOCATING+PROVIDE (edata = .);}
 113   ${RELOCATING+__bss_start = .;}
 114   .sbss    ${RELOCATING-0} : { *(.sbss) *(.scommon) } ${RELOCATING+ >DATA}
 115   .bss     ${RELOCATING-0} :
 116   {
 117    *(.dynbss)
 118    *(.bss)
 119    *(COMMON)
 120   } ${RELOCATING+ >DATA}
 121   ${RELOCATING+_end = . ;}
 122   ${RELOCATING+PROVIDE (end = .);}
 123
 124   ${RELOCATING+$STACK}
 125
 126   /* Stabs debugging sections.  */
 127   .stab 0 : { *(.stab) }
 128   .stabstr 0 : { *(.stabstr) }
 129   .stab.excl 0 : { *(.stab.excl) }
 130   .stab.exclstr 0 : { *(.stab.exclstr) }
 131   .stab.index 0 : { *(.stab.index) }
 132   .stab.indexstr 0 : { *(.stab.indexstr) }
 133
 134   .comment 0 : { *(.comment) }
 135
 136   /* DWARF debug sections.
 137      Symbols in the DWARF debugging sections are relative to the beginning
 138      of the section so we begin them at 0.  */
 139
 140   /* DWARF 1 */
 141   .debug          0 : { *(.debug) }
 142   .line           0 : { *(.line) }
 143
 144   /* GNU DWARF 1 extensions */
 145   .debug_srcinfo  0 : { *(.debug_srcinfo) }
 146   .debug_sfnames  0 : { *(.debug_sfnames) }
 147
 148   /* DWARF 1.1 and DWARF 2 */
 149   .debug_aranges  0 : { *(.debug_aranges) }
 150   .debug_pubnames 0 : { *(.debug_pubnames) }
 151
 152   /* DWARF 2 */
 153   .debug_info     0 : { *(.debug_info) }
 154   .debug_abbrev   0 : { *(.debug_abbrev) }
 155   .debug_line     0 : { *(.debug_line) }
 156   .debug_frame    0 : { *(.debug_frame) }
 157   .debug_str      0 : { *(.debug_str) }
 158   .debug_loc      0 : { *(.debug_loc) }
 159   .debug_macinfo  0 : { *(.debug_macinfo) }
 160
 161   /* SGI/MIPS DWARF 2 extensions */
 162   .debug_weaknames 0 : { *(.debug_weaknames) }
 163   .debug_funcnames 0 : { *(.debug_funcnames) }
 164   .debug_typenames 0 : { *(.debug_typenames) }
 165   .debug_varnames  0 : { *(.debug_varnames) }
 166 }
 167 EOF