ld/scripttempl/elf.sc

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