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 .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" && LARGE_BSS="
 217   .lbss ${RELOCATING-0} :
 218   {
 219     *(.dynlbss)
 220     *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
 221     *(LARGE_COMMON)
 222   }"
 223 test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
 224   .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 225   {
 226     *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
 227   }
 228   .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 229   {
 230     *(.ldata${RELOCATING+ .ldata.* .gnu.linkonce.l.*})
 231     ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 232   }"
 233 if test "${ENABLE_INITFINI_ARRAY}" = "yes"; then
 234   SORT_INIT_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))"
 235   SORT_FINI_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))"
 236   CTORS_IN_INIT_ARRAY="KEEP (*(EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))"
 237   DTORS_IN_FINI_ARRAY="KEEP (*(EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))"
 238 else
 239   SORT_INIT_ARRAY="KEEP (*(SORT(.init_array.*)))"
 240   SORT_FINI_ARRAY="KEEP (*(SORT(.fini_array.*)))"
 241   CTORS_IN_INIT_ARRAY=
 242   DTORS_IN_FINI_ARRAY=
 243 fi
 244 INIT_ARRAY=".init_array   ${RELOCATING-0} :
 245   {
 246     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_start = .);}}
 247     ${SORT_INIT_ARRAY}
 248     KEEP (*(.init_array))
 249     ${CTORS_IN_INIT_ARRAY}
 250     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_end = .);}}
 251   }"
 252 FINI_ARRAY=".fini_array   ${RELOCATING-0} :
 253   {
 254     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_start = .);}}
 255     ${SORT_FINI_ARRAY}
 256     KEEP (*(.fini_array))
 257     ${DTORS_IN_FINI_ARRAY}
 258     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__fini_array_end = .);}}
 259   }"
 260 CTOR=".ctors        ${CONSTRUCTING-0} :
 261   {
 262     ${CONSTRUCTING+${CTOR_START}}
 263     /* gcc uses crtbegin.o to find the start of
 264        the constructors, so we make sure it is
 265        first.  Because this is a wildcard, it
 266        doesn't matter if the user does not
 267        actually link against crtbegin.o; the
 268        linker won't look for a file to match a
 269        wildcard.  The wildcard also means that it
 270        doesn't matter which directory crtbegin.o
 271        is in.  */
 272
 273     KEEP (*crtbegin.o(.ctors))
 274     KEEP (*crtbegin?.o(.ctors))
 275
 276     /* We don't want to include the .ctor section from
 277        the crtend.o file until after the sorted ctors.
 278        The .ctor section from the crtend file contains the
 279        end of ctors marker and it must be last */
 280
 281     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
 282     KEEP (*(SORT(.ctors.*)))
 283     KEEP (*(.ctors))
 284     ${CONSTRUCTING+${CTOR_END}}
 285   }"
 286 DTOR=".dtors        ${CONSTRUCTING-0} :
 287   {
 288     ${CONSTRUCTING+${DTOR_START}}
 289     KEEP (*crtbegin.o(.dtors))
 290     KEEP (*crtbegin?.o(.dtors))
 291     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
 292     KEEP (*(SORT(.dtors.*)))
 293     KEEP (*(.dtors))
 294     ${CONSTRUCTING+${DTOR_END}}
 295   }"
 296 STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
 297   {
 298     ${RELOCATING+${USER_LABEL_PREFIX}_stack = .;}
 299     *(.stack)
 300   }"
 301
 302 TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${TEXT_START_ADDR})"
 303 SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text-segment\", ${SHLIB_TEXT_START_ADDR:-0})"
 304
 305 if [ -z "$SEPARATE_CODE" ]; then
 306   SIZEOF_HEADERS_CODE=" + SIZEOF_HEADERS"
 307 else
 308   SIZEOF_HEADERS_CODE=
 309 fi
 310
 311 # if this is for an embedded system, don't add SIZEOF_HEADERS.
 312 if [ -z "$EMBEDDED" ]; then
 313    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}${SIZEOF_HEADERS_CODE}"
 314 else
 315    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
 316 fi
 317
 318 cat <<EOF
 319 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
 320               "${LITTLE_OUTPUT_FORMAT}")
 321 OUTPUT_ARCH(${OUTPUT_ARCH})
 322 ${RELOCATING+ENTRY(${ENTRY})}
 323
 324 ${RELOCATING+${LIB_SEARCH_DIRS}}
 325 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
 326 ${RELOCATING+${INPUT_FILES}}
 327 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
 328   if gld -r is used and the intermediate file has sections starting
 329   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
 330   bug.  But for now assigning the zero vmas works.  */}
 331
 332 SECTIONS
 333 {
 334   /* Read-only sections, merged into text segment: */
 335   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
 336   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR}${SIZEOF_HEADERS_CODE};}}
 337   ${CREATE_PIE+${RELOCATING+PROVIDE (__executable_start = ${SHLIB_TEXT_START_ADDR}); . = ${SHLIB_TEXT_START_ADDR}${SIZEOF_HEADERS_CODE};}}
 338 EOF
 339
 340 emit_early_ro()
 341 {
 342   cat <<EOF
 343   ${INITIAL_READONLY_SECTIONS}
 344   .note.gnu.build-id : { *(.note.gnu.build-id) }
 345 EOF
 346 }
 347
 348 test -n "${SEPARATE_CODE}" || emit_early_ro
 349
 350 test -n "${RELOCATING+0}" || unset NON_ALLOC_DYN
 351 test -z "${NON_ALLOC_DYN}" || TEXT_DYNAMIC=
 352 cat > ldscripts/dyntmp.$$ <<EOF
 353   ${TEXT_DYNAMIC+${DYNAMIC}}
 354   .hash         ${RELOCATING-0} : { *(.hash) }
 355   .gnu.hash     ${RELOCATING-0} : { *(.gnu.hash) }
 356   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
 357   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
 358   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
 359   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
 360   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
 361 EOF
 362
 363 if [ "x$COMBRELOC" = x ]; then
 364   COMBRELOCCAT="cat >> ldscripts/dyntmp.$$"
 365 else
 366   COMBRELOCCAT="cat > $COMBRELOC"
 367 fi
 368 eval $COMBRELOCCAT <<EOF
 369   ${INITIAL_RELOC_SECTIONS}
 370   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
 371   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
 372   .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
 373   .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
 374   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
 375   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
 376   .rel.${RODATA_NAME}   ${RELOCATING-0} : { *(.rel.${RODATA_NAME}${RELOCATING+ .rel.${RODATA_NAME}.* .rel.gnu.linkonce.r.*}) }
 377   .rela.${RODATA_NAME}  ${RELOCATING-0} : { *(.rela.${RODATA_NAME}${RELOCATING+ .rela.${RODATA_NAME}.* .rela.gnu.linkonce.r.*}) }
 378   ${OTHER_READONLY_RELOC_SECTIONS}
 379   .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+ .rel.data.rel.ro.* .rel.gnu.linkonce.d.rel.ro.*}) }
 380   .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+ .rela.data.rel.ro.* .rela.gnu.linkonce.d.rel.ro.*}) }
 381   .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
 382   .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
 383   ${OTHER_READWRITE_RELOC_SECTIONS}
 384   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 385   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 386   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 387   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 388   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
 389   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
 390   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
 391   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
 392   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
 393   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
 394   ${OTHER_GOT_RELOC_SECTIONS}
 395   ${REL_SDATA}
 396   ${REL_SBSS}
 397   ${REL_SDATA2}
 398   ${REL_SBSS2}
 399   .rel.${BSS_NAME}      ${RELOCATING-0} : { *(.rel.${BSS_NAME}${RELOCATING+ .rel.${BSS_NAME}.* .rel.gnu.linkonce.b.*}) }
 400   .rela.${BSS_NAME}     ${RELOCATING-0} : { *(.rela.${BSS_NAME}${RELOCATING+ .rela.${BSS_NAME}.* .rela.gnu.linkonce.b.*}) }
 401   ${REL_LARGE}
 402   ${IREL_IN_PLT+$REL_IFUNC}
 403   ${IREL_IN_PLT+$RELA_IFUNC}
 404   ${IREL_IN_PLT-$REL_IPLT}
 405   ${IREL_IN_PLT-$RELA_IPLT}
 406 EOF
 407
 408 if [ -n "$COMBRELOC" ]; then
 409 cat >> ldscripts/dyntmp.$$ <<EOF
 410   .rel.dyn      ${RELOCATING-0} :
 411     {
 412 EOF
 413 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 414 cat >> ldscripts/dyntmp.$$ <<EOF
 415     }
 416   .rela.dyn     ${RELOCATING-0} :
 417     {
 418 EOF
 419 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC >> ldscripts/dyntmp.$$
 420 cat >> ldscripts/dyntmp.$$ <<EOF
 421     }
 422 EOF
 423 fi
 424
 425 cat >> ldscripts/dyntmp.$$ <<EOF
 426   .rel.plt      ${RELOCATING-0} :
 427     {
 428       *(.rel.plt)
 429       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}}
 430       ${IREL_IN_PLT+${RELOCATING+*(.rel.iplt)}}
 431       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}}
 432     }
 433   .rela.plt     ${RELOCATING-0} :
 434     {
 435       *(.rela.plt)
 436       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}}
 437       ${IREL_IN_PLT+${RELOCATING+*(.rela.iplt)}}
 438       ${IREL_IN_PLT+${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}}
 439     }
 440   ${OTHER_PLT_RELOC_SECTIONS}
 441 EOF
 442
 443 emit_dyn()
 444 {
 445   if test -z "${NO_REL_RELOCS}${NO_RELA_RELOCS}"; then
 446     cat ldscripts/dyntmp.$$
 447   else
 448     if test -z "${NO_REL_RELOCS}"; then
 449       sed -e '/^[       ]*\.rela\.[^}]*$/,/}/d' -e '/^[         ]*\.rela\./d' ldscripts/dyntmp.$$
 450     fi
 451     if test -z "${NO_RELA_RELOCS}"; then
 452       sed -e '/^[       ]*\.rel\.[^}]*$/,/}/d' -e '/^[  ]*\.rel\./d' ldscripts/dyntmp.$$
 453     fi
 454   fi
 455   rm -f ldscripts/dyntmp.$$
 456 }
 457
 458 test -n "${NON_ALLOC_DYN}${SEPARATE_CODE}" || emit_dyn
 459
 460 cat <<EOF
 461   .init         ${RELOCATING-0} :
 462   {
 463     ${RELOCATING+${INIT_START}}
 464     KEEP (*(SORT_NONE(.init)))
 465     ${RELOCATING+${INIT_END}}
 466   } ${FILL}
 467
 468   ${TEXT_PLT+${PLT}}
 469   ${TINY_READONLY_SECTION}
 470   .text         ${RELOCATING-0} :
 471   {
 472     ${RELOCATING+${TEXT_START_SYMBOLS}}
 473     ${RELOCATING+*(.text.unlikely .text.*_unlikely)}
 474     ${RELOCATING+*(.text.exit .text.exit.*)}
 475     ${RELOCATING+*(.text.startup .text.startup.*)}
 476     ${RELOCATING+*(.text.hot .text.hot.*)}
 477     *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
 478     /* .gnu.warning sections are handled specially by elf32.em.  */
 479     *(.gnu.warning)
 480     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 481   } ${FILL}
 482   .fini         ${RELOCATING-0} :
 483   {
 484     ${RELOCATING+${FINI_START}}
 485     KEEP (*(SORT_NONE(.fini)))
 486     ${RELOCATING+${FINI_END}}
 487   } ${FILL}
 488   ${RELOCATING+PROVIDE (__${ETEXT_NAME} = .);}
 489   ${RELOCATING+PROVIDE (_${ETEXT_NAME} = .);}
 490   ${RELOCATING+PROVIDE (${ETEXT_NAME} = .);}
 491 EOF
 492
 493 if test -n "${SEPARATE_CODE}"; then
 494   if test -n "${RODATA_ADDR}"; then
 495     RODATA_ADDR="\
 496 SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR}) + SIZEOF_HEADERS"
 497   else
 498     RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 499     RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${RODATA_ADDR})"
 500   fi
 501   if test -n "${SHLIB_RODATA_ADDR}"; then
 502     SHLIB_RODATA_ADDR="\
 503 SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR}) + SIZEOF_HEADERS"
 504   else
 505     SHLIB_RODATA_ADDR="SEGMENT_START(\"rodata-segment\", ${SHLIB_RODATA_ADDR})"
 506     SHLIB_RODATA_ADDR="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 507   fi
 508   cat <<EOF
 509   /* Adjust the address for the rodata segment.  We want to adjust up to
 510      the same address within the page on the next page up.  */
 511   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${RODATA_ADDR};}}}
 512   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_RODATA_ADDR};}}
 513   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_RODATA_ADDR};}}
 514 EOF
 515   emit_early_ro
 516   emit_dyn
 517 fi
 518
 519 cat <<EOF
 520   ${WRITABLE_RODATA-${RODATA}}
 521   .${RODATA_NAME}1      ${RELOCATING-0} : { *(.${RODATA_NAME}1) }
 522   ${CREATE_SHLIB-${SDATA2}}
 523   ${CREATE_SHLIB-${SBSS2}}
 524   ${OTHER_READONLY_SECTIONS}
 525   .eh_frame_hdr : { *(.eh_frame_hdr) }
 526   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
 527   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { *(.gcc_except_table
 528   .gcc_except_table.*) }
 529   /* These sections are generated by the Sun/Oracle C++ compiler.  */
 530   .exception_ranges ${RELOCATING-0} : ONLY_IF_RO { *(.exception_ranges
 531   .exception_ranges*) }
 532
 533   /* Adjust the address for the data segment.  We want to adjust up to
 534      the same address within the page on the next page up.  */
 535   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 536   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 537   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 538
 539   /* Exception handling  */
 540   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
 541   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
 542   .exception_ranges ${RELOCATING-0} : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
 543
 544   /* Thread Local Storage sections  */
 545   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 546   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 547
 548   .preinit_array   ${RELOCATING-0} :
 549   {
 550     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}}
 551     KEEP (*(.preinit_array))
 552     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}}
 553   }
 554   ${RELOCATING+${INIT_ARRAY}}
 555   ${RELOCATING+${FINI_ARRAY}}
 556   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 557   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 558   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 559
 560   ${RELOCATING+${DATARELRO}}
 561   ${OTHER_RELRO_SECTIONS}
 562   ${TEXT_DYNAMIC-${DYNAMIC}}
 563   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 564   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 565   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 566   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 567   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 568   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 569
 570   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 571
 572   .data         ${RELOCATING-0} :
 573   {
 574     ${RELOCATING+${DATA_START_SYMBOLS}}
 575     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 576     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 577   }
 578   .data1        ${RELOCATING-0} : { *(.data1) }
 579   ${WRITABLE_RODATA+${RODATA}}
 580   ${OTHER_READWRITE_SECTIONS}
 581   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 582   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 583   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
 584   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS+. = .; ${OTHER_GOT_SYMBOLS}}}}
 585   ${SDATA_GOT+${GOT}}
 586   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 587   ${SDATA}
 588   ${OTHER_SDATA_SECTIONS}
 589   ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
 590   ${RELOCATING+. = .;}
 591   ${RELOCATING+${USER_LABEL_PREFIX}__bss_start = .;}
 592   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 593   ${SBSS}
 594   ${BSS_PLT+${PLT}}
 595   .${BSS_NAME}          ${RELOCATING-0} :
 596   {
 597    *(.dyn${BSS_NAME})
 598    *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
 599    *(COMMON)
 600    /* Align here to ensure that the .bss section occupies space up to
 601       _end.  Align after .bss to ensure correct alignment even if the
 602       .bss section disappears because there are no input sections.
 603       FIXME: Why do we need it? When there is no .bss section, we don't
 604       pad the .data section.  */
 605    ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 606   }
 607   ${OTHER_BSS_SECTIONS}
 608   ${LARGE_BSS_AFTER_BSS+${LARGE_BSS}}
 609   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 610   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 611 EOF
 612
 613 LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${LARGE_DATA_ADDR-.});"
 614 SHLIB_LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${SHLIB_LARGE_DATA_ADDR-.});"
 615
 616   cat <<EOF
 617   ${RELOCATING+${CREATE_SHLIB-${CREATE_PIE-${LARGE_DATA_ADDR}}}}
 618   ${RELOCATING+${CREATE_SHLIB+${SHLIB_LARGE_DATA_ADDR}}}
 619   ${RELOCATING+${CREATE_PIE+${SHLIB_LARGE_DATA_ADDR}}}
 620   ${LARGE_SECTIONS}
 621   ${LARGE_BSS_AFTER_BSS-${LARGE_BSS}}
 622   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 623   ${RELOCATING+${OTHER_END_SYMBOLS}}
 624   ${RELOCATING+${END_SYMBOLS-${USER_LABEL_PREFIX}_end = .; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
 625   ${RELOCATING+${DATA_SEGMENT_END}}
 626 EOF
 627
 628 test -z "${NON_ALLOC_DYN}" || emit_dyn
 629
 630 cat <<EOF
 631   /* Stabs debugging sections.  */
 632   .stab          0 : { *(.stab) }
 633   .stabstr       0 : { *(.stabstr) }
 634   .stab.excl     0 : { *(.stab.excl) }
 635   .stab.exclstr  0 : { *(.stab.exclstr) }
 636   .stab.index    0 : { *(.stab.index) }
 637   .stab.indexstr 0 : { *(.stab.indexstr) }
 638
 639   .comment       0 : { *(.comment) }
 640
 641   /* DWARF debug sections.
 642      Symbols in the DWARF debugging sections are relative to the beginning
 643      of the section so we begin them at 0.  */
 644
 645   /* DWARF 1 */
 646   .debug          0 : { *(.debug) }
 647   .line           0 : { *(.line) }
 648
 649   /* GNU DWARF 1 extensions */
 650   .debug_srcinfo  0 : { *(.debug_srcinfo) }
 651   .debug_sfnames  0 : { *(.debug_sfnames) }
 652
 653   /* DWARF 1.1 and DWARF 2 */
 654   .debug_aranges  0 : { *(.debug_aranges) }
 655   .debug_pubnames 0 : { *(.debug_pubnames) }
 656
 657   /* DWARF 2 */
 658   .debug_info     0 : { *(.debug_info${RELOCATING+ .gnu.linkonce.wi.*}) }
 659   .debug_abbrev   0 : { *(.debug_abbrev) }
 660   .debug_line     0 : { *(.debug_line) }
 661   .debug_frame    0 : { *(.debug_frame) }
 662   .debug_str      0 : { *(.debug_str) }
 663   .debug_loc      0 : { *(.debug_loc) }
 664   .debug_macinfo  0 : { *(.debug_macinfo) }
 665
 666   /* SGI/MIPS DWARF 2 extensions */
 667   .debug_weaknames 0 : { *(.debug_weaknames) }
 668   .debug_funcnames 0 : { *(.debug_funcnames) }
 669   .debug_typenames 0 : { *(.debug_typenames) }
 670   .debug_varnames  0 : { *(.debug_varnames) }
 671
 672   /* DWARF 3 */
 673   .debug_pubtypes 0 : { *(.debug_pubtypes) }
 674   .debug_ranges   0 : { *(.debug_ranges) }
 675
 676   /* DWARF Extension.  */
 677   .debug_macro    0 : { *(.debug_macro) }
 678
 679   ${TINY_DATA_SECTION}
 680   ${TINY_BSS_SECTION}
 681
 682   ${STACK_ADDR+${STACK}}
 683   ${ATTRS_SECTIONS}
 684   ${OTHER_SECTIONS}
 685   ${RELOCATING+${OTHER_SYMBOLS}}
 686   ${RELOCATING+${DISCARDED}}
 687 }
 688 EOF