ld/scripttempl/arclinux.sc

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