ld/scripttempl/arclinux.sc

   1 # Copyright (C) 2014-2023 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-2023 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     ${RELOCATING+*(SORT(.text.sorted.*))}
 495     *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
 496     /* .gnu.warning sections are handled specially by elf.em.  */
 497     *(.gnu.warning)
 498     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 499   } ${FILL}
 500   .fini         ${RELOCATING-0}${RELOCATING+${FINI_ADDR}} :
 501   {
 502     ${RELOCATING+${FINI_START}}
 503     KEEP (*(SORT_NONE(.fini)))
 504     ${RELOCATING+${FINI_END}}
 505   } ${FILL}
 506   ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
 507   ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
 508   ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
 509 EOF
 510
 511 if test -n "${SEPARATE_CODE}"; then
 512   if test -n "${RODATA_ADDR}"; then
 513     RODATA_ADDR="\
 514 SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR}) + SIZEOF_HEADERS"
 515   else
 516     RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 517     RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR})"
 518   fi
 519   if test -n "${SHLIB_RODATA_ADDR}"; then
 520     SHLIB_RODATA_ADDR="\
 521 SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR}) + SIZEOF_HEADERS"
 522   else
 523     SHLIB_RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR})"
 524     SHLIB_RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 525   fi
 526   cat <<EOF
 527   /* Adjust the address for the rodata segment.  We want to adjust up to
 528      the same address within the page on the next page up.  */
 529   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${RODATA_ADDR};}}}
 530   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_RODATA_ADDR};}}
 531   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_RODATA_ADDR};}}
 532 EOF
 533   emit_early_ro
 534   emit_dyn
 535 fi
 536
 537 cat <<EOF
 538   ${WRITABLE_RODATA-${RODATA}}
 539   .${RODATA_NAME}1      ${RELOCATING-0} : { *(.${RODATA_NAME}1) }
 540   ${CREATE_SHLIB-${SDATA2}}
 541   ${CREATE_SHLIB-${SBSS2}}
 542   ${OTHER_READONLY_SECTIONS}
 543   .eh_frame_hdr ${RELOCATING-0} : { *(.eh_frame_hdr) ${RELOCATING+*(.eh_frame_entry .eh_frame_entry.*)} }
 544   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) ${RELOCATING+*(.eh_frame.*)} }
 545   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table${RELOCATING+ .gcc_except_table.*}) }
 546   .gnu_extab ${RELOCATING-0} : ONLY_IF_RO { *(.gnu_extab*) }
 547   /* These sections are generated by the Sun/Oracle C++ compiler.  */
 548   .exception_ranges ${RELOCATING-0} : ONLY_IF_RO { *(.exception_ranges${RELOCATING+*}) }
 549   ${TEXT_PLT+${PLT_NEXT_DATA+${PLT}}}
 550
 551   /* Adjust the address for the data segment.  We want to adjust up to
 552      the same address within the page on the next page up.  */
 553   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 554   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 555   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 556
 557   /* Exception handling  */
 558   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) ${RELOCATING+*(.eh_frame.*)} }
 559   .gnu_extab    ${RELOCATING-0} : ONLY_IF_RW { *(.gnu_extab) }
 560   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table${RELOCATING+ .gcc_except_table.*}) }
 561   .exception_ranges ${RELOCATING-0} : ONLY_IF_RW { *(.exception_ranges${RELOCATING+*}) }
 562
 563   /* Thread Local Storage sections  */
 564   .tdata        ${RELOCATING-0} : { ${RELOCATING+PROVIDE_HIDDEN(.tdata = .); }*(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 565   .tbss         ${RELOCATING-0} : { ${RELOCATING+PROVIDE_HIDDEN(.tbss = .); }*(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 566
 567   .preinit_array   ${RELOCATING-0} :
 568   {
 569     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}}
 570     KEEP (*(.preinit_array))
 571     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}}
 572   }
 573   ${RELOCATING+${INIT_ARRAY}}
 574   ${RELOCATING+${FINI_ARRAY}}
 575   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 576   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 577   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 578
 579   ${RELOCATING+${DATARELRO}}
 580   ${OTHER_RELRO_SECTIONS}
 581   ${TEXT_DYNAMIC-${DYNAMIC}}
 582   ${OTHER_RELRO_SECTIONS_2}
 583   ${DATA_GOT+${RELRO_NOW+${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}}}
 584   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 585   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 586   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 587   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 588   ${INITIAL_READWRITE_SECTIONS}
 589   ${DATA_SDATA+${SDATA}}
 590   ${DATA_SDATA+${OTHER_SDATA_SECTIONS}}
 591   ${DATA_SDATA+${SBSS}}
 592   ${DATA_GOT+${RELRO_NOW-${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}}}
 593   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 594   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 595
 596   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 597
 598   .data         ${RELOCATING-0} :
 599   {
 600     ${RELOCATING+${DATA_START_SYMBOLS}}
 601     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 602     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 603   }
 604   .data1        ${RELOCATING-0} : { *(.data1) }
 605   ${WRITABLE_RODATA+${RODATA}}
 606   ${OTHER_READWRITE_SECTIONS}
 607   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 608   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 609   ${SDATA_GOT+${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}}
 610   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS+. = .; ${OTHER_GOT_SYMBOLS}}}}
 611   ${SDATA_GOT+${GOT}}
 612   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 613   ${DATA_SDATA-${SDATA}}
 614   ${DATA_SDATA-${OTHER_SDATA_SECTIONS}}
 615   ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
 616   ${RELOCATING+. = ALIGN(ALIGNOF(NEXT_SECTION));}
 617   ${RELOCATING+${USER_LABEL_PREFIX}__bss_start = .;}
 618   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 619   ${DATA_SDATA-${SBSS}}
 620   ${BSS_PLT+${PLT}}
 621   .${BSS_NAME}          ${RELOCATING-0} :
 622   {
 623     ${RELOCATING+*(.dyn${BSS_NAME})}
 624     *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
 625     ${RELOCATING+*(COMMON)
 626     /* Align here to ensure that the .bss section occupies space up to
 627        _end.  Align after .bss to ensure correct alignment even if the
 628        .bss section disappears because there are no input sections.
 629        FIXME: Why do we need it? When there is no .bss section, we do not
 630        pad the .data section.  */
 631     . = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 632   }
 633   ${OTHER_BSS_SECTIONS}
 634   ${LARGE_BSS_AFTER_BSS+${LARGE_BSS}}
 635   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 636   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 637 EOF
 638
 639 LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${LARGE_DATA_ADDR-.});"
 640 SHLIB_LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${SHLIB_LARGE_DATA_ADDR-.});"
 641
 642   cat <<EOF
 643   ${RELOCATING+${CREATE_SHLIB-${CREATE_PIE-${LARGE_DATA_ADDR}}}}
 644   ${RELOCATING+${CREATE_SHLIB+${SHLIB_LARGE_DATA_ADDR}}}
 645   ${RELOCATING+${CREATE_PIE+${SHLIB_LARGE_DATA_ADDR}}}
 646   ${LARGE_SECTIONS}
 647   ${LARGE_BSS_AFTER_BSS-${LARGE_BSS}}
 648   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 649   ${RELOCATING+${OTHER_END_SYMBOLS}}
 650   ${RELOCATING+${END_SYMBOLS-${USER_LABEL_PREFIX}_end = .; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
 651   ${RELOCATING+${DATA_SEGMENT_END}}
 652   ${TINY_DATA_SECTION}
 653   ${TINY_BSS_SECTION}
 654   ${STACK_ADDR+${STACK}}
 655 EOF
 656
 657 test -z "${NON_ALLOC_DYN}" || emit_dyn
 658
 659 source_sh $srcdir/scripttempl/misc-sections.sc
 660 source_sh $srcdir/scripttempl/DWARF.sc
 661
 662 cat <<EOF
 663   ${ATTRS_SECTIONS}
 664   ${OTHER_SECTIONS}
 665   ${RELOCATING+${OTHER_SYMBOLS}}
 666   ${RELOCATING+${DISCARDED}}
 667 }
 668 EOF