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