ld/scripttempl/nds32elf.sc

   1 #  This file is variant of elf.sc.  For nds32, because the data will be
   2 #  classified into different sections according to their size, this script
   3 #  describe these sections map.  The order is ".sdata_d, .sdata_w, .sdata_h,
   4 #  .sdata_b, , sdata_f, .sbss_f, .sbss_b, .sbss_h, .sbss_w, .sbss_d".  In
   5 #  this order we do not have to consider the alignment issue between these
   6 #  sections.
   7
   8 if test -n "$NOP"; then
   9   FILL="=$NOP"
  10 else
  11   FILL=
  12 fi
  13
  14 test -z "$RODATA_NAME" && RODATA_NAME=rodata
  15 test -z "$SDATA_NAME" && SDATA_NAME=sdata
  16 test -z "$SBSS_NAME" && SBSS_NAME=sbss
  17 test -z "$BSS_NAME" && BSS_NAME=bss
  18 test -z "$ENTRY" && ENTRY=${USER_LABEL_PREFIX}_start
  19 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
  20 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
  21 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
  22 test -z "${ELFSIZE}" && ELFSIZE=32
  23 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
  24 test "$LD_FLAG" = "N" && DATA_ADDR=.
  25 test -z "${ETEXT_NAME}" && ETEXT_NAME=${USER_LABEL_PREFIX}etext
  26 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
  27 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
  28 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
  29 test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
  30 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
  31 DATA_SEGMENT_RELRO_END=""
  32 DATA_SEGMENT_END=""
  33 if test -n "${COMMONPAGESIZE}"; then
  34   DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
  35   DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
  36   DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (${SEPARATE_GOTPLT-0}, .);"
  37 fi
  38 if test -z "${INITIAL_READONLY_SECTIONS}${CREATE_SHLIB}"; then
  39   INITIAL_READONLY_SECTIONS=".interp       ${RELOCATING-0} : { *(.interp) }"
  40 fi
  41 if test -z "$PLT"; then
  42   IPLT=".iplt         ${RELOCATING-0} : { *(.iplt) }"
  43   PLT=".plt          ${RELOCATING-0} : { *(.plt)${IREL_IN_PLT+ *(.iplt)} }
  44   ${IREL_IN_PLT-$IPLT}"
  45 fi
  46 test -n "${DATA_PLT-${BSS_PLT-text}}" && TEXT_PLT=
  47 if test -z "$GOT"; then
  48   if test -z "$SEPARATE_GOTPLT"; then
  49     GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.igot.plt) *(.got) *(.igot) }"
  50   else
  51     GOT=".got          ${RELOCATING-0} : { *(.got) *(.igot) }"
  52     GOTPLT=".got.plt      ${RELOCATING-0} : { *(.got.plt)  *(.igot.plt) }"
  53   fi
  54 fi
  55 REL_IFUNC=".rel.ifunc    ${RELOCATING-0} : { *(.rel.ifunc) }"
  56 RELA_IFUNC=".rela.ifunc   ${RELOCATING-0} : { *(.rela.ifunc) }"
  57 REL_IPLT=".rel.iplt     ${RELOCATING-0} :
  58     {
  59       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}
  60       *(.rel.iplt)
  61       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}
  62     }"
  63 RELA_IPLT=".rela.iplt    ${RELOCATING-0} :
  64     {
  65       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}
  66       *(.rela.iplt)
  67       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}
  68     }"
  69 DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
  70 RODATA=".${RODATA_NAME}       ${RELOCATING-0} : { *(.${RODATA_NAME}${RELOCATING+ .${RODATA_NAME}.* .gnu.linkonce.r.*}) }"
  71 DATARELRO=".data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }"
  72 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }"
  73 if test -z "${NO_SMALL_DATA}"; then
  74   SBSS=".sbss_b         ${RELOCATING-0} :
  75   {
  76     *(.sbss_b${RELOCATING+ .sbss_b.*})
  77     *(.scommon_b${RELOCATING+ .scommon_b.*})
  78     ${RELOCATING+. = ALIGN(2);}
  79   }
  80   .sbss_h         ${RELOCATING-0} :
  81   {
  82     *(.sbss_h${RELOCATING+ .sbss_h.*})
  83     *(.scommon_h${RELOCATING+ .scommon_h.*})
  84     ${RELOCATING+. = ALIGN(4);}
  85   }
  86   .sbss_w         ${RELOCATING-0} :
  87   {
  88     *(.sbss_w${RELOCATING+ .sbss_w.*})
  89     *(.scommon_w${RELOCATING+ .scommon_w.*})
  90     *(.dynsbss)
  91     *(.scommon)
  92     ${RELOCATING+. = ALIGN(8);}
  93   }
  94   .sbss_d         ${RELOCATING-0} :
  95   {
  96     *(.sbss_d${RELOCATING+ .sbss_d.*})
  97     *(.scommon_d${RELOCATING+ .scommon_d.*})
  98     ${RELOCATING+PROVIDE (__sbss_end = .);}
  99     ${RELOCATING+PROVIDE (___sbss_end = .);}
 100   }"
 101   SBSS2=".${SBSS_NAME}2        ${RELOCATING-0} : { *(.${SBSS_NAME}2${RELOCATING+ .${SBSS_NAME}2.* .gnu.linkonce.sb2.*}) }"
 102   SDATA="/* We want the small data sections together, so single-instruction offsets
 103      can access them all, and initialized data all before uninitialized, so
 104      we can shorten the on-disk segment size.  */
 105   .${SDATA_NAME}        ${RELOCATING-0} :
 106   {
 107     ${RELOCATING+${SDATA_START_SYMBOLS}}
 108     ${CREATE_SHLIB+*(.${SDATA_NAME}2 .${SDATA_NAME}2.* .gnu.linkonce.s2.*)}
 109     *(.${SDATA_NAME}${RELOCATING+ .${SDATA_NAME}.* .gnu.linkonce.s.*})
 110   }
 111   .sdata_d        ${RELOCATING-0} :
 112   {
 113     *(.sdata_d${RELOCATING+ .sdata_d.*})
 114   }
 115   .sdata_w        ${RELOCATING-0} :
 116   {
 117     *(.sdata_w${RELOCATING+ .sdata_w.*})
 118   }
 119   .sdata_h        ${RELOCATING-0} :
 120   {
 121     *(.sdata_h${RELOCATING+ .sdata_h.*})
 122   }
 123   .sdata_b        ${RELOCATING-0} :
 124   {
 125     *(.sdata_b${RELOCATING+ .sdata_b.*})
 126   }
 127   .sdata_f        ${RELOCATING-0} :
 128   {
 129     *(.sdata_f${RELOCATING+ .sdata_f.*})
 130   }"
 131   SDATA2=".${SDATA_NAME}2       ${RELOCATING-0} :
 132   {
 133     ${RELOCATING+${SDATA2_START_SYMBOLS}}
 134     *(.${SDATA_NAME}2${RELOCATING+ .${SDATA_NAME}2.* .gnu.linkonce.s2.*})
 135   }"
 136   REL_SDATA=".rel.${SDATA_NAME}    ${RELOCATING-0} : { *(.rel.${SDATA_NAME}${RELOCATING+ .rel.${SDATA_NAME}.* .rel.gnu.linkonce.s.*}) }
 137   .rela.${SDATA_NAME}   ${RELOCATING-0} : { *(.rela.${SDATA_NAME}${RELOCATING+ .rela.${SDATA_NAME}.* .rela.gnu.linkonce.s.*}) }"
 138   REL_SBSS=".rel.${SBSS_NAME}     ${RELOCATING-0} : { *(.rel.${SBSS_NAME}${RELOCATING+ .rel.${SBSS_NAME}.* .rel.gnu.linkonce.sb.*}) }
 139   .rela.${SBSS_NAME}    ${RELOCATING-0} : { *(.rela.${SBSS_NAME}${RELOCATING+ .rela.${SBSS_NAME}.* .rela.gnu.linkonce.sb.*}) }"
 140   REL_SDATA2=".rel.${SDATA_NAME}2   ${RELOCATING-0} : { *(.rel.${SDATA_NAME}2${RELOCATING+ .rel.${SDATA_NAME}2.* .rel.gnu.linkonce.s2.*}) }
 141   .rela.${SDATA_NAME}2  ${RELOCATING-0} : { *(.rela.${SDATA_NAME}2${RELOCATING+ .rela.${SDATA_NAME}2.* .rela.gnu.linkonce.s2.*}) }"
 142   REL_SBSS2=".rel.${SBSS_NAME}2    ${RELOCATING-0} : { *(.rel.${SBSS_NAME}2${RELOCATING+ .rel.${SBSS_NAME}2.* .rel.gnu.linkonce.sb2.*}) }
 143   .rela.${SBSS_NAME}2   ${RELOCATING-0} : { *(.rela.${SBSS_NAME}2${RELOCATING+ .rela.${SBSS_NAME}2.* .rela.gnu.linkonce.sb2.*}) }"
 144 else
 145   NO_SMALL_DATA=" "
 146 fi
 147 if test -z "${DATA_GOT}"; then
 148   if test -n "${NO_SMALL_DATA}"; then
 149     DATA_GOT=" "
 150   fi
 151 fi
 152 if test -z "${SDATA_GOT}"; then
 153   if test -z "${NO_SMALL_DATA}"; then
 154     SDATA_GOT=" "
 155   fi
 156 fi
 157 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
 158 test "${LARGE_SECTIONS}" = "yes" && REL_LARGE="
 159   .rel.ldata    ${RELOCATING-0} : { *(.rel.ldata${RELOCATING+ .rel.ldata.* .rel.gnu.linkonce.l.*}) }
 160   .rela.ldata   ${RELOCATING-0} : { *(.rela.ldata${RELOCATING+ .rela.ldata.* .rela.gnu.linkonce.l.*}) }
 161   .rel.lbss     ${RELOCATING-0} : { *(.rel.lbss${RELOCATING+ .rel.lbss.* .rel.gnu.linkonce.lb.*}) }
 162   .rela.lbss    ${RELOCATING-0} : { *(.rela.lbss${RELOCATING+ .rela.lbss.* .rela.gnu.linkonce.lb.*}) }
 163   .rel.lrodata  ${RELOCATING-0} : { *(.rel.lrodata${RELOCATING+ .rel.lrodata.* .rel.gnu.linkonce.lr.*}) }
 164   .rela.lrodata ${RELOCATING-0} : { *(.rela.lrodata${RELOCATING+ .rela.lrodata.* .rela.gnu.linkonce.lr.*}) }"
 165 test "${LARGE_SECTIONS}" = "yes" && LARGE_BSS="
 166   .lbss ${RELOCATING-0} :
 167   {
 168     *(.dynlbss)
 169     *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
 170     *(LARGE_COMMON)
 171   }"
 172 test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
 173   .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 174   {
 175     *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
 176   }
 177   .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 178   {
 179     *(.ldata${RELOCATING+ .ldata.* .gnu.linkonce.l.*})
 180     ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 181   }"
 182 if test "${ENABLE_INITFINI_ARRAY}" = "yes"; then
 183   SORT_INIT_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))"
 184   SORT_FINI_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))"
 185   CTORS_IN_INIT_ARRAY="EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors"
 186   DTORS_IN_FINI_ARRAY="EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors"
 187 else
 188   SORT_INIT_ARRAY="KEEP (*(SORT(.init_array.*)))"
 189   SORT_FINI_ARRAY="KEEP (*(SORT(.fini_array.*)))"
 190   CTORS_IN_INIT_ARRAY=
 191   DTORS_IN_FINI_ARRAY=
 192 fi
 193 INIT_ARRAY=".init_array   ${RELOCATING-0} :
 194   {
 195     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_start = .);}}
 196     ${SORT_INIT_ARRAY}
 197     KEEP (*(.init_array ${CTORS_IN_INIT_ARRAY}))
 198     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_end = .);}}
 199   }"
 200 FINI_ARRAY=".fini_array   ${RELOCATING-0} :
 201   {
 202     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_start = .);}}
 203     ${SORT_FINI_ARRAY}
 204     KEEP (*(.fini_array ${DTORS_IN_FINI_ARRAY}))
 205     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_end = .);}}
 206   }"
 207 CTOR=".ctors        ${CONSTRUCTING-0} :
 208   {
 209     ${CONSTRUCTING+${CTOR_START}}
 210     /* gcc uses crtbegin.o to find the start of
 211        the constructors, so we make sure it is
 212        first.  Because this is a wildcard, it
 213        doesn't matter if the user does not
 214        actually link against crtbegin.o; the
 215        linker won't look for a file to match a
 216        wildcard.  The wildcard also means that it
 217        doesn't matter which directory crtbegin.o
 218        is in.  */
 219
 220     KEEP (*crtbegin.o(.ctors))
 221     KEEP (*crtbegin?.o(.ctors))
 222
 223     /* We don't want to include the .ctor section from
 224        the crtend.o file until after the sorted ctors.
 225        The .ctor section from the crtend file contains the
 226        end of ctors marker and it must be last */
 227
 228     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
 229     KEEP (*(SORT(.ctors.*)))
 230     KEEP (*(.ctors))
 231     ${CONSTRUCTING+${CTOR_END}}
 232   }"
 233 DTOR=".dtors        ${CONSTRUCTING-0} :
 234   {
 235     ${CONSTRUCTING+${DTOR_START}}
 236     KEEP (*crtbegin.o(.dtors))
 237     KEEP (*crtbegin?.o(.dtors))
 238     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
 239     KEEP (*(SORT(.dtors.*)))
 240     KEEP (*(.dtors))
 241     ${CONSTRUCTING+${DTOR_END}}
 242   }"
 243 STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
 244   {
 245     ${RELOCATING+${USER_LABEL_PREFIX}_stack = .;}
 246     *(.stack)
 247   }"
 248
 249 TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${TEXT_START_ADDR})"
 250 SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${SHLIB_TEXT_START_ADDR:-0})"
 251
 252 if [ -z "$SEPARATE_CODE" ]; then
 253   SIZEOF_HEADERS_CODE=" + SIZEOF_HEADERS"
 254 else
 255   SIZEOF_HEADERS_CODE=
 256 fi
 257
 258 # if this is for an embedded system, don't add SIZEOF_HEADERS.
 259 if [ -z "$EMBEDDED" ]; then
 260    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}${SIZEOF_HEADERS_CODE}"
 261     NDS32_INIT=""
 262 else
 263    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
 264    NDS32_INIT=".nds32_init     : { KEEP(*(.nds32_init)) }"
 265 fi
 266
 267 cat <<EOF
 268 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
 269               "${LITTLE_OUTPUT_FORMAT}")
 270 OUTPUT_ARCH(${OUTPUT_ARCH})
 271 ${RELOCATING+ENTRY(${ENTRY})}
 272
 273 ${RELOCATING+${LIB_SEARCH_DIRS}}
 274 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
 275 ${RELOCATING+${INPUT_FILES}}
 276 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
 277   if gld -r is used and the intermediate file has sections starting
 278   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
 279   bug.  But for now assigning the zero vmas works.  */}
 280
 281 SECTIONS
 282 {
 283   /* Read-only sections, merged into text segment: */
 284   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
 285   /* Sections saved crt0 and crt1.  */
 286   ${NDS32_INIT}
 287   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR}${SIZEOF_HEADERS_CODE};}}
 288   ${CREATE_PIE+${RELOCATING+PROVIDE (__executable_start = ${SHLIB_TEXT_START_ADDR}); . = ${SHLIB_TEXT_START_ADDR}${SIZEOF_HEADERS_CODE};}}
 289 EOF
 290
 291 emit_early_ro()
 292 {
 293   cat <<EOF
 294   ${INITIAL_READONLY_SECTIONS}
 295   .note.gnu.build-id : { *(.note.gnu.build-id) }
 296 EOF
 297 }
 298
 299 test -n "${SEPARATE_CODE}" || emit_early_ro
 300
 301 test -n "${RELOCATING+0}" || unset NON_ALLOC_DYN
 302 test -z "${NON_ALLOC_DYN}" || TEXT_DYNAMIC=
 303 cat > ldscripts/dyntmp.$$ <<EOF
 304   ${TEXT_DYNAMIC+${DYNAMIC}}
 305   .hash         ${RELOCATING-0} : { *(.hash) }
 306   .gnu.hash     ${RELOCATING-0} : { *(.gnu.hash) }
 307   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
 308   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
 309   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
 310   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
 311   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
 312 EOF
 313
 314 if [ "x$COMBRELOC" = x ]; then
 315   COMBRELOCCAT="cat >> ldscripts/dyntmp.$$"
 316 else
 317   COMBRELOCCAT="cat > $COMBRELOC"
 318 fi
 319 eval $COMBRELOCCAT <<EOF
 320   ${INITIAL_RELOC_SECTIONS}
 321   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
 322   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
 323   .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
 324   .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
 325   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
 326   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
 327   .rel.${RODATA_NAME}   ${RELOCATING-0} : { *(.rel.${RODATA_NAME}${RELOCATING+ .rel.${RODATA_NAME}.* .rel.gnu.linkonce.r.*}) }
 328   .rela.${RODATA_NAME}  ${RELOCATING-0} : { *(.rela.${RODATA_NAME}${RELOCATING+ .rela.${RODATA_NAME}.* .rela.gnu.linkonce.r.*}) }
 329   ${OTHER_READONLY_RELOC_SECTIONS}
 330   .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+ .rel.data.rel.ro.* .rel.gnu.linkonce.d.rel.ro.*}) }
 331   .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+ .rela.data.rel.ro.* .rela.gnu.linkonce.d.rel.ro.*}) }
 332   .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
 333   .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
 334   ${OTHER_READWRITE_RELOC_SECTIONS}
 335   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 336   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 337   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 338   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 339   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
 340   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
 341   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
 342   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
 343   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
 344   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
 345   ${OTHER_GOT_RELOC_SECTIONS}
 346   ${REL_SDATA}
 347   ${REL_SBSS}
 348   ${REL_SDATA2}
 349   ${REL_SBSS2}
 350   .rel.${BSS_NAME}      ${RELOCATING-0} : { *(.rel.${BSS_NAME}${RELOCATING+ .rel.${BSS_NAME}.* .rel.gnu.linkonce.b.*}) }
 351   .rela.${BSS_NAME}     ${RELOCATING-0} : { *(.rela.${BSS_NAME}${RELOCATING+ .rela.${BSS_NAME}.* .rela.gnu.linkonce.b.*}) }
 352   ${REL_LARGE}
 353   ${IREL_IN_PLT+$REL_IFUNC}
 354   ${IREL_IN_PLT+$RELA_IFUNC}
 355   ${IREL_IN_PLT-$REL_IPLT}
 356   ${IREL_IN_PLT-$RELA_IPLT}
 357 EOF
 358
 359 if [ -n "$COMBRELOC" ]; then
 360 cat >> ldscripts/dyntmp.$$ <<EOF
 361   .rel.dyn      ${RELOCATING-0} :
 362     {
 363 EOF
 364 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 365 cat >> ldscripts/dyntmp.$$ <<EOF
 366     }
 367   .rela.dyn     ${RELOCATING-0} :
 368     {
 369 EOF
 370 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 371 cat >> ldscripts/dyntmp.$$ <<EOF
 372     }
 373 EOF
 374 fi
 375
 376 cat >> ldscripts/dyntmp.$$ <<EOF
 377   .rel.plt      ${RELOCATING-0} :
 378     {
 379       *(.rel.plt)
 380       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}}
 381       ${IREL_IN_PLT+${RELOCATING+*(.rel.iplt)}}
 382       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}}
 383     }
 384   .rela.plt     ${RELOCATING-0} :
 385     {
 386       *(.rela.plt)
 387       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}}
 388       ${IREL_IN_PLT+${RELOCATING+*(.rela.iplt)}}
 389       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}}
 390     }
 391   ${OTHER_PLT_RELOC_SECTIONS}
 392 EOF
 393
 394 emit_dyn()
 395 {
 396   if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
 397     cat ldscripts/dyntmp.$$
 398   else
 399     if test -z "${NO_REL_RELOCS}"; then
 400       sed -e '/^[       ]*\.rela\.[^}]*$/,/}/d' -e '/^[         ]*\.rela\./d' ldscripts/dyntmp.$$
 401     fi
 402     if test -z "${NO_RELA_RELOCS}"; then
 403       sed -e '/^[       ]*\.rel\.[^}]*$/,/}/d' -e '/^[  ]*\.rel\./d' ldscripts/dyntmp.$$
 404     fi
 405   fi
 406   rm -f ldscripts/dyntmp.$$
 407 }
 408
 409 test -n "${NON_ALLOC_DYN}${SEPARATE_CODE}" || emit_dyn
 410
 411 cat <<EOF
 412   .init         ${RELOCATING-0} :
 413   {
 414     ${RELOCATING+${INIT_START}}
 415     KEEP (*(SORT_NONE(.init)))
 416     ${RELOCATING+${INIT_END}}
 417   } ${FILL}
 418
 419   ${TEXT_PLT+${PLT_NEXT_DATA-${PLT}}}
 420   ${TINY_READONLY_SECTION}
 421   .text         ${RELOCATING-0} :
 422   {
 423     ${RELOCATING+${TEXT_START_SYMBOLS}}
 424     ${RELOCATING+*(.text.unlikely .text.*_unlikely .text.unlikely.*)}
 425     ${RELOCATING+*(.text.exit .text.exit.*)}
 426     ${RELOCATING+*(.text.startup .text.startup.*)}
 427     ${RELOCATING+*(.text.hot .text.hot.*)}
 428     *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
 429     /* .gnu.warning sections are handled specially by elf32.em.  */
 430     *(.gnu.warning)
 431     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 432   } ${FILL}
 433   .fini         ${RELOCATING-0} :
 434   {
 435     ${RELOCATING+${FINI_START}}
 436     KEEP (*(SORT_NONE(.fini)))
 437     ${RELOCATING+${FINI_END}}
 438   } ${FILL}
 439   ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
 440   ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
 441   ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
 442 EOF
 443
 444 if test -n "${SEPARATE_CODE}"; then
 445   if test -n "${RODATA_ADDR}"; then
 446     RODATA_ADDR="\
 447 SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR}) + SIZEOF_HEADERS"
 448   else
 449     RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 450     RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR})"
 451   fi
 452   if test -n "${SHLIB_RODATA_ADDR}"; then
 453     SHLIB_RODATA_ADDR="\
 454 SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR}) + SIZEOF_HEADERS"
 455   else
 456     SHLIB_RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR})"
 457     SHLIB_RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 458   fi
 459   cat <<EOF
 460   /* Adjust the address for the rodata segment.  We want to adjust up to
 461      the same address within the page on the next page up.  */
 462   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${RODATA_ADDR};}}}
 463   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_RODATA_ADDR};}}
 464   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_RODATA_ADDR};}}
 465 EOF
 466   emit_early_ro
 467   emit_dyn
 468 fi
 469
 470 cat <<EOF
 471   ${WRITABLE_RODATA-${RODATA}}
 472   .${RODATA_NAME}1      ${RELOCATING-0} : { *(.${RODATA_NAME}1) }
 473   ${CREATE_SHLIB-${SDATA2}}
 474   ${CREATE_SHLIB-${SBSS2}}
 475   ${OTHER_READONLY_SECTIONS}
 476   .eh_frame_hdr : { *(.eh_frame_hdr) }
 477   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
 478   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table
 479   .gcc_except_table.*) }
 480   /* These sections are generated by the Sun/Oracle C++ compiler.  */
 481   .exception_ranges ${RELOCATING-0} : ONLY_IF_RO { *(.exception_ranges
 482   .exception_ranges*) }
 483   ${TEXT_PLT+${PLT_NEXT_DATA+${PLT}}}
 484
 485   /* Adjust the address for the data segment.  We want to adjust up to
 486      the same address within the page on the next page up.  */
 487   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 488   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 489   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 490
 491   /* Exception handling  */
 492   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
 493   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
 494   .exception_ranges ${RELOCATING-0} : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
 495
 496   /* Thread Local Storage sections  */
 497   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 498   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 499
 500   .preinit_array   ${RELOCATING-0} :
 501   {
 502     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}}
 503     KEEP (*(.preinit_array))
 504     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}}
 505   }
 506   ${RELOCATING+${INIT_ARRAY}}
 507   ${RELOCATING+${FINI_ARRAY}}
 508   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 509   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 510   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 511
 512   ${RELOCATING+${DATARELRO}}
 513   ${OTHER_RELRO_SECTIONS}
 514   ${TEXT_DYNAMIC-${DYNAMIC}}
 515   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 516   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 517   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 518   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 519   ${INITIAL_READWRITE_SECTIONS}
 520   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 521   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 522
 523   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 524
 525   /*  For _SDA_BASE_ aligment.  */
 526   ${RELOCATING+. = ALIGN(4);}
 527
 528   .data         ${RELOCATING-0} :
 529   {
 530     ${RELOCATING+${DATA_START_SYMBOLS}}
 531     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 532     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 533   }
 534   .data1        ${RELOCATING-0} : { *(.data1) }
 535   ${WRITABLE_RODATA+${RODATA}}
 536   ${OTHER_READWRITE_SECTIONS}
 537   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 538   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 539   ${RELOCATING+. = ALIGN(4);}
 540   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
 541   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS+. = .; ${OTHER_GOT_SYMBOLS}}}}
 542   ${SDATA_GOT+${GOT}}
 543   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 544   ${SDATA}
 545   ${OTHER_SDATA_SECTIONS}
 546   ${RELOCATING+. = ALIGN(4);}
 547   ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
 548   ${RELOCATING+. = .;}
 549   ${RELOCATING+${USER_LABEL_PREFIX}__bss_start = .;}
 550   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 551   ${SBSS}
 552   ${BSS_PLT+${PLT}}
 553   .${BSS_NAME}          ${RELOCATING-0} :
 554   {
 555    *(.dyn${BSS_NAME})
 556    *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
 557    *(COMMON)
 558    /* Align here to ensure that the .bss section occupies space up to
 559       _end.  Align after .bss to ensure correct alignment even if the
 560       .bss section disappears because there are no input sections.
 561       FIXME: Why do we need it? When there is no .bss section, we don't
 562       pad the .data section.  */
 563    ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 564   }
 565   ${OTHER_BSS_SECTIONS}
 566   ${LARGE_BSS_AFTER_BSS+${LARGE_BSS}}
 567   ${RELOCATING+_end = .;}
 568   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 569   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 570 EOF
 571
 572 LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${LARGE_DATA_ADDR-.});"
 573 SHLIB_LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${SHLIB_LARGE_DATA_ADDR-.});"
 574
 575   cat <<EOF
 576   ${RELOCATING+${CREATE_SHLIB-${CREATE_PIE-${LARGE_DATA_ADDR}}}}
 577   ${RELOCATING+${CREATE_SHLIB+${SHLIB_LARGE_DATA_ADDR}}}
 578   ${RELOCATING+${CREATE_PIE+${SHLIB_LARGE_DATA_ADDR}}}
 579   ${LARGE_SECTIONS}
 580   ${LARGE_BSS_AFTER_BSS-${LARGE_BSS}}
 581   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 582   ${RELOCATING+${OTHER_END_SYMBOLS}}
 583   ${RELOCATING+${END_SYMBOLS-${USER_LABEL_PREFIX}_end = .; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
 584   ${RELOCATING+${DATA_SEGMENT_END}}
 585 EOF
 586
 587 test -z "${NON_ALLOC_DYN}" || emit_dyn
 588
 589 cat <<EOF
 590   /* Stabs debugging sections.  */
 591   .stab          0 : { *(.stab) }
 592   .stabstr       0 : { *(.stabstr) }
 593   .stab.excl     0 : { *(.stab.excl) }
 594   .stab.exclstr  0 : { *(.stab.exclstr) }
 595   .stab.index    0 : { *(.stab.index) }
 596   .stab.indexstr 0 : { *(.stab.indexstr) }
 597
 598   .comment       0 : { *(.comment) }
 599
 600 EOF
 601
 602 . $srcdir/scripttempl/DWARF.sc
 603
 604 cat <<EOF
 605
 606   ${TINY_DATA_SECTION}
 607   ${TINY_BSS_SECTION}
 608
 609   ${STACK_ADDR+${STACK}}
 610   ${ATTRS_SECTIONS}
 611   ${OTHER_SECTIONS}
 612   ${RELOCATING+${OTHER_SYMBOLS}}
 613   ${RELOCATING+${DISCARDED}}
 614 }
 615 EOF