contrib/binutils-2.24/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 #       INITIAL_READWRITE_SECTIONS - at start of data segment (after relro)
  14 #       OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
  15 #               (e.g., .PARISC.global)
  16 #       OTHER_RELRO_SECTIONS - other than .data.rel.ro ...
  17 #               (e.g. PPC32 .fixup, .got[12])
  18 #       OTHER_BSS_SECTIONS - other than .bss .sbss ...
  19 #       ATTRS_SECTIONS - at the end
  20 #       OTHER_SECTIONS - at the end
  21 #       EXECUTABLE_SYMBOLS - symbols that must be defined for an
  22 #               executable (e.g., _DYNAMIC_LINK)
  23 #       TEXT_START_ADDR - the first byte of the text segment, after any
  24 #               headers.
  25 #       TEXT_BASE_ADDRESS - the first byte of the text segment.
  26 #       TEXT_START_SYMBOLS - symbols that appear at the start of the
  27 #               .text section.
  28 #       DATA_START_SYMBOLS - symbols that appear at the start of the
  29 #               .data section.
  30 #       DATA_END_SYMBOLS - symbols that appear at the end of the
  31 #               writeable data sections.
  32 #       OTHER_GOT_SYMBOLS - symbols defined just before .got.
  33 #       OTHER_GOT_SECTIONS - sections just after .got.
  34 #       OTHER_SDATA_SECTIONS - sections just after .sdata.
  35 #       OTHER_BSS_SYMBOLS - symbols that appear at the start of the
  36 #               .bss section besides __bss_start.
  37 #       PLT_NEXT_DATA - .plt next to data segment when .plt is in text segment.
  38 #       DATA_PLT - .plt should be in data segment, not text segment.
  39 #       PLT_BEFORE_GOT - .plt just before .got when .plt is in data segement.
  40 #       BSS_PLT - .plt should be in bss segment
  41 #       NO_REL_RELOCS - Don't include .rel.* sections in script
  42 #       NO_RELA_RELOCS - Don't include .rela.* sections in script
  43 #       NON_ALLOC_DYN - Place dynamic sections after data segment.
  44 #       TEXT_DYNAMIC - .dynamic in text segment, not data segment.
  45 #       EMBEDDED - whether this is for an embedded system.
  46 #       SHLIB_TEXT_START_ADDR - if set, add to SIZEOF_HEADERS to set
  47 #               start address of shared library.
  48 #       INPUT_FILES - INPUT command of files to always include
  49 #       WRITABLE_RODATA - if set, the .rodata section should be writable
  50 #       INIT_START, INIT_END -  statements just before and just after
  51 #       combination of .init sections.
  52 #       FINI_START, FINI_END - statements just before and just after
  53 #       combination of .fini sections.
  54 #       STACK_ADDR - start of a .stack section.
  55 #       OTHER_SYMBOLS - symbols to place right at the end of the script.
  56 #       ETEXT_NAME - name of a symbol for the end of the text section,
  57 #               normally etext.
  58 #       SEPARATE_CODE - if set, .text and similar sections containing
  59 #               actual machine instructions must be in wholly disjoint
  60 #               pages from any other data, including headers
  61 #       SEPARATE_GOTPLT - if set, .got.plt should be separate output section,
  62 #               so that .got can be in the RELRO area.  It should be set to
  63 #               the number of bytes in the beginning of .got.plt which can be
  64 #               in the RELRO area as well.
  65 #       USER_LABEL_PREFIX - prefix to add to user-visible symbols.
  66 #       RODATA_NAME, SDATA_NAME, SBSS_NAME, BSS_NAME - base parts of names
  67 #               for standard sections, without initial "." or suffixes.
  68 #
  69 # When adding sections, do note that the names of some sections are used
  70 # when specifying the start address of the next.
  71 #
  72
  73 #  Many sections come in three flavours.  There is the 'real' section,
  74 #  like ".data".  Then there are the per-procedure or per-variable
  75 #  sections, generated by -ffunction-sections and -fdata-sections in GCC,
  76 #  and useful for --gc-sections, which for a variable "foo" might be
  77 #  ".data.foo".  Then there are the linkonce sections, for which the linker
  78 #  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".
  79 #  The exact correspondences are:
  80 #
  81 #  Section      Linkonce section
  82 #  .text        .gnu.linkonce.t.foo
  83 #  .rodata      .gnu.linkonce.r.foo
  84 #  .data        .gnu.linkonce.d.foo
  85 #  .bss         .gnu.linkonce.b.foo
  86 #  .sdata       .gnu.linkonce.s.foo
  87 #  .sbss        .gnu.linkonce.sb.foo
  88 #  .sdata2      .gnu.linkonce.s2.foo
  89 #  .sbss2       .gnu.linkonce.sb2.foo
  90 #  .debug_info  .gnu.linkonce.wi.foo
  91 #  .tdata       .gnu.linkonce.td.foo
  92 #  .tbss        .gnu.linkonce.tb.foo
  93 #  .lrodata     .gnu.linkonce.lr.foo
  94 #  .ldata       .gnu.linkonce.l.foo
  95 #  .lbss        .gnu.linkonce.lb.foo
  96 #
  97 #  Each of these can also have corresponding .rel.* and .rela.* sections.
  98
  99 if test -n "$NOP"; then
 100   FILL="=$NOP"
 101 else
 102   FILL=
 103 fi
 104
 105 test -z "$RODATA_NAME" && RODATA_NAME=rodata
 106 test -z "$SDATA_NAME" && SDATA_NAME=sdata
 107 test -z "$SBSS_NAME" && SBSS_NAME=sbss
 108 test -z "$BSS_NAME" && BSS_NAME=bss
 109 test -z "$ENTRY" && ENTRY=${USER_LABEL_PREFIX}_start
 110 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 111 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
 112 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
 113 test -z "${ELFSIZE}" && ELFSIZE=32
 114 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
 115 test "$LD_FLAG" = "N" && DATA_ADDR=.
 116 test -z "${ETEXT_NAME}" && ETEXT_NAME=${USER_LABEL_PREFIX}etext
 117 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
 118 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
 119 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
 120 test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
 121 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
 122 DATA_SEGMENT_RELRO_END=""
 123 DATA_SEGMENT_END=""
 124 if test -n "${COMMONPAGESIZE}"; then
 125   DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
 126   DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
 127   DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (${SEPARATE_GOTPLT-0}, .);"
 128 fi
 129 if test -z "${INITIAL_READONLY_SECTIONS}${CREATE_SHLIB}"; then
 130   INITIAL_READONLY_SECTIONS=".interp       ${RELOCATING-0} : { *(.interp) }"
 131 fi
 132 if test -z "$PLT"; then
 133   IPLT=".iplt         ${RELOCATING-0} : { *(.iplt) }"
 134   PLT=".plt          ${RELOCATING-0} : { *(.plt)${IREL_IN_PLT+ *(.iplt)} }
 135   ${IREL_IN_PLT-$IPLT}"
 136 fi
 137 test -n "${DATA_PLT-${BSS_PLT-text}}" && TEXT_PLT=
 138 if test -z "$GOT"; then
 139   if test -z "$SEPARATE_GOTPLT"; then
 140     GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.igot.plt) *(.got) *(.igot) }"
 141   else
 142     GOT=".got          ${RELOCATING-0} : { *(.got) *(.igot) }"
 143     GOTPLT=".got.plt      ${RELOCATING-0} : { *(.got.plt)  *(.igot.plt) }"
 144   fi
 145 fi
 146 REL_IFUNC=".rel.ifunc    ${RELOCATING-0} : { *(.rel.ifunc) }"
 147 RELA_IFUNC=".rela.ifunc   ${RELOCATING-0} : { *(.rela.ifunc) }"
 148 REL_IPLT=".rel.iplt     ${RELOCATING-0} :
 149     {
 150       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_start = .);}}
 151       *(.rel.iplt)
 152       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rel_iplt_end = .);}}
 153     }"
 154 RELA_IPLT=".rela.iplt    ${RELOCATING-0} :
 155     {
 156       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_start = .);}}
 157       *(.rela.iplt)
 158       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}
 159     }"
 160 DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
 161 RODATA=".${RODATA_NAME}       ${RELOCATING-0} : { *(.${RODATA_NAME}${RELOCATING+ .${RODATA_NAME}.* .gnu.linkonce.r.*}) }"
 162 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.*) }"
 163 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }"
 164 if test -z "${NO_SMALL_DATA}"; then
 165   SBSS=".${SBSS_NAME}         ${RELOCATING-0} :
 166   {
 167     ${RELOCATING+${SBSS_START_SYMBOLS}}
 168     ${CREATE_SHLIB+*(.${SBSS_NAME}2 .${SBSS_NAME}2.* .gnu.linkonce.sb2.*)}
 169     *(.dyn${SBSS_NAME})
 170     *(.${SBSS_NAME}${RELOCATING+ .${SBSS_NAME}.* .gnu.linkonce.sb.*})
 171     *(.scommon)
 172     ${RELOCATING+${SBSS_END_SYMBOLS}}
 173   }"
 174   SBSS2=".${SBSS_NAME}2        ${RELOCATING-0} : { *(.${SBSS_NAME}2${RELOCATING+ .${SBSS_NAME}2.* .gnu.linkonce.sb2.*}) }"
 175   SDATA="/* We want the small data sections together, so single-instruction offsets
 176      can access them all, and initialized data all before uninitialized, so
 177      we can shorten the on-disk segment size.  */
 178   .${SDATA_NAME}        ${RELOCATING-0} :
 179   {
 180     ${RELOCATING+${SDATA_START_SYMBOLS}}
 181     ${CREATE_SHLIB+*(.${SDATA_NAME}2 .${SDATA_NAME}2.* .gnu.linkonce.s2.*)}
 182     *(.${SDATA_NAME}${RELOCATING+ .${SDATA_NAME}.* .gnu.linkonce.s.*})
 183   }"
 184   SDATA2=".${SDATA_NAME}2       ${RELOCATING-0} :
 185   {
 186     ${RELOCATING+${SDATA2_START_SYMBOLS}}
 187     *(.${SDATA_NAME}2${RELOCATING+ .${SDATA_NAME}2.* .gnu.linkonce.s2.*})
 188   }"
 189   REL_SDATA=".rel.${SDATA_NAME}    ${RELOCATING-0} : { *(.rel.${SDATA_NAME}${RELOCATING+ .rel.${SDATA_NAME}.* .rel.gnu.linkonce.s.*}) }
 190   .rela.${SDATA_NAME}   ${RELOCATING-0} : { *(.rela.${SDATA_NAME}${RELOCATING+ .rela.${SDATA_NAME}.* .rela.gnu.linkonce.s.*}) }"
 191   REL_SBSS=".rel.${SBSS_NAME}     ${RELOCATING-0} : { *(.rel.${SBSS_NAME}${RELOCATING+ .rel.${SBSS_NAME}.* .rel.gnu.linkonce.sb.*}) }
 192   .rela.${SBSS_NAME}    ${RELOCATING-0} : { *(.rela.${SBSS_NAME}${RELOCATING+ .rela.${SBSS_NAME}.* .rela.gnu.linkonce.sb.*}) }"
 193   REL_SDATA2=".rel.${SDATA_NAME}2   ${RELOCATING-0} : { *(.rel.${SDATA_NAME}2${RELOCATING+ .rel.${SDATA_NAME}2.* .rel.gnu.linkonce.s2.*}) }
 194   .rela.${SDATA_NAME}2  ${RELOCATING-0} : { *(.rela.${SDATA_NAME}2${RELOCATING+ .rela.${SDATA_NAME}2.* .rela.gnu.linkonce.s2.*}) }"
 195   REL_SBSS2=".rel.${SBSS_NAME}2    ${RELOCATING-0} : { *(.rel.${SBSS_NAME}2${RELOCATING+ .rel.${SBSS_NAME}2.* .rel.gnu.linkonce.sb2.*}) }
 196   .rela.${SBSS_NAME}2   ${RELOCATING-0} : { *(.rela.${SBSS_NAME}2${RELOCATING+ .rela.${SBSS_NAME}2.* .rela.gnu.linkonce.sb2.*}) }"
 197 else
 198   NO_SMALL_DATA=" "
 199 fi
 200 if test -z "${DATA_GOT}"; then
 201   if test -n "${NO_SMALL_DATA}"; then
 202     DATA_GOT=" "
 203   fi
 204 fi
 205 if test -z "${SDATA_GOT}"; then
 206   if test -z "${NO_SMALL_DATA}"; then
 207     SDATA_GOT=" "
 208   fi
 209 fi
 210 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
 211 test "${LARGE_SECTIONS}" = "yes" && REL_LARGE="
 212   .rel.ldata    ${RELOCATING-0} : { *(.rel.ldata${RELOCATING+ .rel.ldata.* .rel.gnu.linkonce.l.*}) }
 213   .rela.ldata   ${RELOCATING-0} : { *(.rela.ldata${RELOCATING+ .rela.ldata.* .rela.gnu.linkonce.l.*}) }
 214   .rel.lbss     ${RELOCATING-0} : { *(.rel.lbss${RELOCATING+ .rel.lbss.* .rel.gnu.linkonce.lb.*}) }
 215   .rela.lbss    ${RELOCATING-0} : { *(.rela.lbss${RELOCATING+ .rela.lbss.* .rela.gnu.linkonce.lb.*}) }
 216   .rel.lrodata  ${RELOCATING-0} : { *(.rel.lrodata${RELOCATING+ .rel.lrodata.* .rel.gnu.linkonce.lr.*}) }
 217   .rela.lrodata ${RELOCATING-0} : { *(.rela.lrodata${RELOCATING+ .rela.lrodata.* .rela.gnu.linkonce.lr.*}) }"
 218 test "${LARGE_SECTIONS}" = "yes" && LARGE_BSS="
 219   .lbss ${RELOCATING-0} :
 220   {
 221     *(.dynlbss)
 222     *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
 223     *(LARGE_COMMON)
 224   }"
 225 test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
 226   .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 227   {
 228     *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
 229   }
 230   .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
 231   {
 232     *(.ldata${RELOCATING+ .ldata.* .gnu.linkonce.l.*})
 233     ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 234   }"
 235 if test "${ENABLE_INITFINI_ARRAY}" = "yes"; then
 236   SORT_INIT_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))"
 237   SORT_FINI_ARRAY="KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))"
 238   CTORS_IN_INIT_ARRAY="EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors"
 239   DTORS_IN_FINI_ARRAY="EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors"
 240 else
 241   SORT_INIT_ARRAY="KEEP (*(SORT(.init_array.*)))"
 242   SORT_FINI_ARRAY="KEEP (*(SORT(.fini_array.*)))"
 243   CTORS_IN_INIT_ARRAY=
 244   DTORS_IN_FINI_ARRAY=
 245 fi
 246 INIT_ARRAY=".init_array   ${RELOCATING-0} :
 247   {
 248     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__init_array_start = .);}}
 249     ${SORT_INIT_ARRAY}
 250     KEEP (*(.init_array ${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 ${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_NEXT_DATA-${PLT}}}
 469   ${TINY_READONLY_SECTION}
 470   .text         ${RELOCATING-0} :
 471   {
 472     ${RELOCATING+${TEXT_START_SYMBOLS}}
 473     ${RELOCATING+*(.text.unlikely .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   ${TEXT_PLT+${PLT_NEXT_DATA+${PLT}}}
 533
 534   /* Adjust the address for the data segment.  We want to adjust up to
 535      the same address within the page on the next page up.  */
 536   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 537   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 538   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 539
 540   /* Exception handling  */
 541   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
 542   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
 543   .exception_ranges ${RELOCATING-0} : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
 544
 545   /* Thread Local Storage sections  */
 546   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 547   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 548
 549   .preinit_array   ${RELOCATING-0} :
 550   {
 551     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_start = .);}}
 552     KEEP (*(.preinit_array))
 553     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__preinit_array_end = .);}}
 554   }
 555   ${RELOCATING+${INIT_ARRAY}}
 556   ${RELOCATING+${FINI_ARRAY}}
 557   ${SMALL_DATA_CTOR-${RELOCATING+${CTOR}}}
 558   ${SMALL_DATA_DTOR-${RELOCATING+${DTOR}}}
 559   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 560
 561   ${RELOCATING+${DATARELRO}}
 562   ${OTHER_RELRO_SECTIONS}
 563   ${TEXT_DYNAMIC-${DYNAMIC}}
 564   ${DATA_GOT+${RELRO_NOW+${GOT}}}
 565   ${DATA_GOT+${RELRO_NOW+${GOTPLT}}}
 566   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT+${GOT}}}}
 567   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 568   ${INITIAL_READWRITE_SECTIONS}
 569   ${DATA_GOT+${RELRO_NOW-${SEPARATE_GOTPLT-${GOT}}}}
 570   ${DATA_GOT+${RELRO_NOW-${GOTPLT}}}
 571
 572   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 573
 574   .data         ${RELOCATING-0} :
 575   {
 576     ${RELOCATING+${DATA_START_SYMBOLS}}
 577     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 578     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 579   }
 580   .data1        ${RELOCATING-0} : { *(.data1) }
 581   ${WRITABLE_RODATA+${RODATA}}
 582   ${OTHER_READWRITE_SECTIONS}
 583   ${SMALL_DATA_CTOR+${RELOCATING+${CTOR}}}
 584   ${SMALL_DATA_DTOR+${RELOCATING+${DTOR}}}
 585   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
 586   ${SDATA_GOT+${RELOCATING+${OTHER_GOT_SYMBOLS+. = .; ${OTHER_GOT_SYMBOLS}}}}
 587   ${SDATA_GOT+${GOT}}
 588   ${SDATA_GOT+${OTHER_GOT_SECTIONS}}
 589   ${SDATA}
 590   ${OTHER_SDATA_SECTIONS}
 591   ${RELOCATING+${DATA_END_SYMBOLS-${USER_LABEL_PREFIX}_edata = .; PROVIDE (${USER_LABEL_PREFIX}edata = .);}}
 592   ${RELOCATING+. = .;}
 593   ${RELOCATING+${USER_LABEL_PREFIX}__bss_start = .;}
 594   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 595   ${SBSS}
 596   ${BSS_PLT+${PLT}}
 597   .${BSS_NAME}          ${RELOCATING-0} :
 598   {
 599    *(.dyn${BSS_NAME})
 600    *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
 601    *(COMMON)
 602    /* Align here to ensure that the .bss section occupies space up to
 603       _end.  Align after .bss to ensure correct alignment even if the
 604       .bss section disappears because there are no input sections.
 605       FIXME: Why do we need it? When there is no .bss section, we don't
 606       pad the .data section.  */
 607    ${RELOCATING+. = ALIGN(. != 0 ? ${ALIGNMENT} : 1);}
 608   }
 609   ${OTHER_BSS_SECTIONS}
 610   ${LARGE_BSS_AFTER_BSS+${LARGE_BSS}}
 611   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 612   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 613 EOF
 614
 615 LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${LARGE_DATA_ADDR-.});"
 616 SHLIB_LARGE_DATA_ADDR=". = SEGMENT_START(\"ldata-segment\", ${SHLIB_LARGE_DATA_ADDR-.});"
 617
 618   cat <<EOF
 619   ${RELOCATING+${CREATE_SHLIB-${CREATE_PIE-${LARGE_DATA_ADDR}}}}
 620   ${RELOCATING+${CREATE_SHLIB+${SHLIB_LARGE_DATA_ADDR}}}
 621   ${RELOCATING+${CREATE_PIE+${SHLIB_LARGE_DATA_ADDR}}}
 622   ${LARGE_SECTIONS}
 623   ${LARGE_BSS_AFTER_BSS-${LARGE_BSS}}
 624   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 625   ${RELOCATING+${OTHER_END_SYMBOLS}}
 626   ${RELOCATING+${END_SYMBOLS-${USER_LABEL_PREFIX}_end = .; PROVIDE (${USER_LABEL_PREFIX}end = .);}}
 627   ${RELOCATING+${DATA_SEGMENT_END}}
 628 EOF
 629
 630 test -z "${NON_ALLOC_DYN}" || emit_dyn
 631
 632 cat <<EOF
 633   /* Stabs debugging sections.  */
 634   .stab          0 : { *(.stab) }
 635   .stabstr       0 : { *(.stabstr) }
 636   .stab.excl     0 : { *(.stab.excl) }
 637   .stab.exclstr  0 : { *(.stab.exclstr) }
 638   .stab.index    0 : { *(.stab.index) }
 639   .stab.indexstr 0 : { *(.stab.indexstr) }
 640
 641   .comment       0 : { *(.comment) }
 642
 643 EOF
 644
 645 . $srcdir/scripttempl/DWARF.sc
 646
 647 cat <<EOF
 648
 649   ${TINY_DATA_SECTION}
 650   ${TINY_BSS_SECTION}
 651
 652   ${STACK_ADDR+${STACK}}
 653   ${ATTRS_SECTIONS}
 654   ${OTHER_SECTIONS}
 655   ${RELOCATING+${OTHER_SYMBOLS}}
 656   ${RELOCATING+${DISCARDED}}
 657 }
 658 EOF