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