ld/scripttempl/armbpabi.sc

   1 # This variant of elf.sc is used for ARM BPABI platforms, like Symbian
   2 # OS, where a separate postlinker will operated on the generated
   3 # executable or shared object.  See elf.sc for configuration variables
   4 # that apply; only BPABI-specific variables will be noted here.
   5
   6 test -z "$ENTRY" && ENTRY=_start
   7 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
   8 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
   9 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
  10 test -z "${ELFSIZE}" && ELFSIZE=32
  11 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
  12 test "$LD_FLAG" = "N" && DATA_ADDR=.
  13 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
  14 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
  15 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
  16 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
  17 DATA_SEGMENT_RELRO_END=""
  18 DATA_SEGMENT_RELRO_GOTPLT_END=""
  19 DATA_SEGMENT_END=""
  20 if test -n "${COMMONPAGESIZE}"; then
  21   DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
  22   DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
  23   if test -n "${SEPARATE_GOTPLT}"; then
  24     DATA_SEGMENT_RELRO_GOTPLT_END=". = DATA_SEGMENT_RELRO_END (. + ${SEPARATE_GOTPLT});"
  25   else
  26     DATA_SEGMENT_RELRO_END=". = DATA_SEGMENT_RELRO_END (.);"
  27   fi
  28 fi
  29 INTERP=".interp       0 : { *(.interp) }"
  30 PLT=".plt          ${RELOCATING-0} : { *(.plt) }"
  31 RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
  32 DATARELRO=".data.rel.ro : { *(.data.rel.ro.local) *(.data.rel.ro*) }"
  33 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink)  *(.gnu.lto_*) }"
  34 if test -z "${NO_SMALL_DATA}"; then
  35   SBSS=".sbss         ${RELOCATING-0} :
  36   {
  37     ${RELOCATING+PROVIDE (__sbss_start = .);}
  38     ${RELOCATING+PROVIDE (___sbss_start = .);}
  39     *(.dynsbss)
  40     *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})
  41     *(.scommon)
  42     ${RELOCATING+PROVIDE (__sbss_end = .);}
  43     ${RELOCATING+PROVIDE (___sbss_end = .);}
  44   }"
  45   SBSS2=".sbss2        ${RELOCATING-0} : { *(.sbss2${RELOCATING+ .sbss2.* .gnu.linkonce.sb2.*}) }"
  46   SDATA="/* We want the small data sections together, so single-instruction offsets
  47      can access them all, and initialized data all before uninitialized, so
  48      we can shorten the on-disk segment size.  */
  49   .sdata        ${RELOCATING-0} :
  50   {
  51     ${RELOCATING+${SDATA_START_SYMBOLS}}
  52     *(.sdata${RELOCATING+ .sdata.* .gnu.linkonce.s.*})
  53   }"
  54   SDATA2=".sdata2       ${RELOCATING-0} : { *(.sdata2${RELOCATING+ .sdata2.* .gnu.linkonce.s2.*}) }"
  55   REL_SDATA=".rel.sdata    ${RELOCATING-0} : { *(.rel.sdata${RELOCATING+ .rel.sdata.* .rel.gnu.linkonce.s.*}) }
  56   .rela.sdata   ${RELOCATING-0} : { *(.rela.sdata${RELOCATING+ .rela.sdata.* .rela.gnu.linkonce.s.*}) }"
  57   REL_SBSS=".rel.sbss     ${RELOCATING-0} : { *(.rel.sbss${RELOCATING+ .rel.sbss.* .rel.gnu.linkonce.sb.*}) }
  58   .rela.sbss    ${RELOCATING-0} : { *(.rela.sbss${RELOCATING+ .rela.sbss.* .rela.gnu.linkonce.sb.*}) }"
  59   REL_SDATA2=".rel.sdata2   ${RELOCATING-0} : { *(.rel.sdata2${RELOCATING+ .rel.sdata2.* .rel.gnu.linkonce.s2.*}) }
  60   .rela.sdata2  ${RELOCATING-0} : { *(.rela.sdata2${RELOCATING+ .rela.sdata2.* .rela.gnu.linkonce.s2.*}) }"
  61   REL_SBSS2=".rel.sbss2    ${RELOCATING-0} : { *(.rel.sbss2${RELOCATING+ .rel.sbss2.* .rel.gnu.linkonce.sb2.*}) }
  62   .rela.sbss2   ${RELOCATING-0} : { *(.rela.sbss2${RELOCATING+ .rela.sbss2.* .rela.gnu.linkonce.sb2.*}) }"
  63 else
  64   NO_SMALL_DATA=" "
  65 fi
  66 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
  67 INIT_ARRAY=".init_array   ${RELOCATING-0} :
  68   {
  69     /* SymbianOS uses this symbol.  */
  70     ${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Base = .);}
  71     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_start = .);}}
  72     KEEP (*(SORT(.init_array.*)))
  73     KEEP (*(.init_array))
  74     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__init_array_end = .);}}
  75     /* SymbianOS uses this symbol.  */
  76     ${RELOCATING+PROVIDE (SHT\$\$INIT_ARRAY\$\$Limit = .);}
  77   }"
  78 FINI_ARRAY=".fini_array   ${RELOCATING-0} :
  79   {
  80     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_start = .);}}
  81     KEEP (*(SORT(.fini_array.*)))
  82     KEEP (*(.fini_array))
  83     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__fini_array_end = .);}}
  84   }"
  85 CTOR=".ctors        ${CONSTRUCTING-0} :
  86   {
  87     ${CONSTRUCTING+${CTOR_START}}
  88     /* gcc uses crtbegin.o to find the start of
  89        the constructors, so we make sure it is
  90        first.  Because this is a wildcard, it
  91        doesn't matter if the user does not
  92        actually link against crtbegin.o; the
  93        linker won't look for a file to match a
  94        wildcard.  The wildcard also means that it
  95        doesn't matter which directory crtbegin.o
  96        is in.  */
  97
  98     KEEP (*crtbegin.o(.ctors))
  99     KEEP (*crtbegin?.o(.ctors))
 100
 101     /* We don't want to include the .ctor section from
 102        the crtend.o file until after the sorted ctors.
 103        The .ctor section from the crtend file contains the
 104        end of ctors marker and it must be last */
 105
 106     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .ctors))
 107     KEEP (*(SORT(.ctors.*)))
 108     KEEP (*(.ctors))
 109     ${CONSTRUCTING+${CTOR_END}}
 110   }"
 111 DTOR=".dtors        ${CONSTRUCTING-0} :
 112   {
 113     ${CONSTRUCTING+${DTOR_START}}
 114     KEEP (*crtbegin.o(.dtors))
 115     KEEP (*crtbegin?.o(.dtors))
 116     KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o $OTHER_EXCLUDE_FILES) .dtors))
 117     KEEP (*(SORT(.dtors.*)))
 118     KEEP (*(.dtors))
 119     ${CONSTRUCTING+${DTOR_END}}
 120   }"
 121 STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
 122   {
 123     ${RELOCATING+_stack = .;}
 124     *(.stack)
 125   }"
 126
 127 TEXT_START_ADDR="SEGMENT_START(\"text\", ${TEXT_START_ADDR})"
 128 SHLIB_TEXT_START_ADDR="SEGMENT_START(\"text\", ${SHLIB_TEXT_START_ADDR:-0})"
 129 DATA_ADDR="SEGMENT_START(\"data\", ${DATA_ADDR-${DATA_SEGMENT_ALIGN}})"
 130 SHLIB_DATA_ADDR="SEGMENT_START(\"data\", ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}})"
 131
 132 # if this is for an embedded system, don't add SIZEOF_HEADERS.
 133 if [ -z "$EMBEDDED" ]; then
 134    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
 135    SHLIB_BASE_ADDRESS="${SHLIB_TEXT_START_ADDR} + SIZEOF_HEADERS"
 136 else
 137    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
 138    SHLIB_BASE_ADDRESS="${SHLIB_TEXT_START_ADDR}"
 139 fi
 140
 141 cat <<EOF
 142 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
 143               "${LITTLE_OUTPUT_FORMAT}")
 144 OUTPUT_ARCH(${OUTPUT_ARCH})
 145 ${RELOCATING+ENTRY(${ENTRY})}
 146
 147 ${RELOCATING+${LIB_SEARCH_DIRS}}
 148 ${RELOCATING+/* Do we need any of these for elf?
 149    __DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}}  */}
 150 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
 151 ${RELOCATING+${INPUT_FILES}}
 152 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
 153   if gld -r is used and the intermediate file has sections starting
 154   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
 155   bug.  But for now assigning the zero vmas works.  */}
 156
 157 /* ARM's proprietary toolchain generate these symbols to match the start
 158    and end of particular sections of the image.  SymbianOS uses these
 159    symbols.  We provide them for compatibility with ARM's toolchains.
 160    These symbols should be bound locally; each shared object may define
 161    its own version of these symbols.  */
 162
 163 VERSION
 164 {
 165   /* Give these a dummy version to work around linker lameness.
 166      The name used shouldn't matter as these are all local symbols.  */
 167   __GNU {
 168     local:
 169       Image\$\$ER_RO\$\$Base;
 170       Image\$\$ER_RO\$\$Limit;
 171       SHT\$\$INIT_ARRAY\$\$Base;
 172       SHT\$\$INIT_ARRAY\$\$Limit;
 173       .ARM.exidx\$\$Base;
 174       .ARM.exidx\$\$Limit;
 175   };
 176 }
 177
 178 SECTIONS
 179 {
 180   /* Read-only sections, merged into text segment: */
 181   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR});}}}
 182
 183   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+ . = ${TEXT_BASE_ADDRESS};}}}
 184   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_BASE_ADDRESS};}}
 185   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_BASE_ADDRESS};}}
 186
 187   /* Define Image\$\$ER_RO\$\$Base.  */
 188   ${RELOCATING+PROVIDE (Image\$\$ER_RO\$\$Base = .);}
 189
 190   ${INITIAL_READONLY_SECTIONS}
 191
 192 EOF
 193 cat <<EOF
 194   .init         ${RELOCATING-0} :
 195   {
 196     ${RELOCATING+${INIT_START}}
 197     KEEP (*(.init))
 198     ${RELOCATING+${INIT_END}}
 199   } =${NOP-0}
 200   .text         ${RELOCATING-0} :
 201   {
 202     ${RELOCATING+${TEXT_START_SYMBOLS}}
 203     *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
 204     /* .gnu.warning sections are handled specially by elf32.em.  */
 205     *(.gnu.warning)
 206     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 207   } =${NOP-0}
 208   .fini         ${RELOCATING-0} :
 209   {
 210     ${RELOCATING+${FINI_START}}
 211     KEEP (*(.fini))
 212     ${RELOCATING+${FINI_END}}
 213   } =${NOP-0}
 214   /* The SymbianOS kernel requires that the PLT go at the end of the
 215      text section.  */
 216   ${DATA_PLT-${BSS_PLT-${PLT}}}
 217   ${RELOCATING+PROVIDE (__etext = .);}
 218   ${RELOCATING+PROVIDE (_etext = .);}
 219   ${RELOCATING+PROVIDE (etext = .);}
 220
 221   /* Define Image\$\$ER_RO\$\$Limit.  */
 222   ${RELOCATING+PROVIDE (Image\$\$ER_RO\$\$Limit = .);}
 223
 224   ${WRITABLE_RODATA-${RODATA}}
 225   .rodata1      ${RELOCATING-0} : { *(.rodata1) }
 226   ${CREATE_SHLIB-${SDATA2}}
 227   ${CREATE_SHLIB-${SBSS2}}
 228
 229   /* On SymbianOS, put  .init_array and friends in the read-only
 230      segment; there is no runtime relocation applied to these
 231      arrays.  */
 232
 233   .preinit_array   ${RELOCATING-0} :
 234   {
 235     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_start = .);}}
 236     KEEP (*(.preinit_array))
 237     ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (__preinit_array_end = .);}}
 238   }
 239   ${RELOCATING+${INIT_ARRAY}}
 240   ${RELOCATING+${FINI_ARRAY}}
 241
 242   ${OTHER_READONLY_SECTIONS}
 243   .eh_frame_hdr : { *(.eh_frame_hdr) }
 244   .eh_frame     ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.eh_frame)) }
 245   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }
 246
 247   /* Adjust the address for the data segment.  We want to adjust up to
 248      the same address within the page on the next page up.  */
 249   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR};}}}
 250   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR};}}
 251   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR};}}
 252
 253   /* Exception handling  */
 254   .eh_frame     ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.eh_frame)) }
 255   .gcc_except_table ${RELOCATING-0} : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }
 256
 257   /* Thread Local Storage sections  */
 258   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 259   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 260
 261   ${RELOCATING+${CTOR}}
 262   ${RELOCATING+${DTOR}}
 263   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 264
 265   ${RELOCATING+${DATARELRO}}
 266   ${OTHER_RELRO_SECTIONS}
 267   ${RELOCATING+${DATA_SEGMENT_RELRO_END}}
 268
 269   ${DATA_PLT+${PLT_BEFORE_GOT-${PLT}}}
 270
 271   .data         ${RELOCATING-0} :
 272   {
 273     ${RELOCATING+${DATA_START_SYMBOLS}}
 274     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 275     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 276   }
 277   .data1        ${RELOCATING-0} : { *(.data1) }
 278   ${WRITABLE_RODATA+${RODATA}}
 279   ${OTHER_READWRITE_SECTIONS}
 280   ${DATA_PLT+${PLT_BEFORE_GOT+${PLT}}}
 281   ${CREATE_SHLIB+${SDATA2}}
 282   ${CREATE_SHLIB+${SBSS2}}
 283   ${SDATA}
 284   ${OTHER_SDATA_SECTIONS}
 285   ${RELOCATING+_edata = .;}
 286   ${RELOCATING+PROVIDE (edata = .);}
 287   ${RELOCATING+. = DEFINED(__bss_segment_start) ? __bss_segment_start : .;}
 288   ${RELOCATING+__bss_start = .;}
 289   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 290   ${SBSS}
 291   ${BSS_PLT+${PLT}}
 292   .bss          ${RELOCATING-0} :
 293   {
 294    *(.dynbss)
 295    *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
 296    *(COMMON)
 297    /* Align here to ensure that the .bss section occupies space up to
 298       _end.  Align after .bss to ensure correct alignment even if the
 299       .bss section disappears because there are no input sections.  */
 300    ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 301   }
 302   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 303   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 304   ${RELOCATING+${OTHER_END_SYMBOLS}}
 305   ${RELOCATING+_end = .;}
 306   ${RELOCATING+PROVIDE (end = .);}
 307   ${RELOCATING+${DATA_SEGMENT_END}}
 308
 309   /* These sections are not mapped under the BPABI.  */
 310   .dynamic      0 : { *(.dynamic) }
 311   .hash         0 : { *(.hash) }
 312   .dynsym       0 : { *(.dynsym) }
 313   .dynstr       0 : { *(.dynstr) }
 314   .gnu.version  0 : { *(.gnu.version) }
 315   .gnu.version_d 0: { *(.gnu.version_d) }
 316   .gnu.version_r 0: { *(.gnu.version_r) }
 317   ${CREATE_SHLIB-${INTERP}}
 318
 319   /* Stabs debugging sections.  */
 320   .stab          0 : { *(.stab) }
 321   .stabstr       0 : { *(.stabstr) }
 322   .stab.excl     0 : { *(.stab.excl) }
 323   .stab.exclstr  0 : { *(.stab.exclstr) }
 324   .stab.index    0 : { *(.stab.index) }
 325   .stab.indexstr 0 : { *(.stab.indexstr) }
 326
 327   .comment       0 : { *(.comment) }
 328
 329   /* DWARF debug sections.
 330      Symbols in the DWARF debugging sections are relative to the beginning
 331      of the section so we begin them at 0.  */
 332
 333   /* DWARF 1 */
 334   .debug          0 : { *(.debug) }
 335   .line           0 : { *(.line) }
 336
 337   /* GNU DWARF 1 extensions */
 338   .debug_srcinfo  0 : { *(.debug_srcinfo) }
 339   .debug_sfnames  0 : { *(.debug_sfnames) }
 340
 341   /* DWARF 1.1 and DWARF 2 */
 342   .debug_aranges  0 : { *(.debug_aranges) }
 343   .debug_pubnames 0 : { *(.debug_pubnames) }
 344
 345   /* DWARF 2 */
 346   .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
 347   .debug_abbrev   0 : { *(.debug_abbrev) }
 348   .debug_line     0 : { *(.debug_line) }
 349   .debug_frame    0 : { *(.debug_frame) }
 350   .debug_str      0 : { *(.debug_str) }
 351   .debug_loc      0 : { *(.debug_loc) }
 352   .debug_macinfo  0 : { *(.debug_macinfo) }
 353
 354   /* SGI/MIPS DWARF 2 extensions */
 355   .debug_weaknames 0 : { *(.debug_weaknames) }
 356   .debug_funcnames 0 : { *(.debug_funcnames) }
 357   .debug_typenames 0 : { *(.debug_typenames) }
 358   .debug_varnames  0 : { *(.debug_varnames) }
 359
 360   ${STACK_ADDR+${STACK}}
 361   ${OTHER_SECTIONS}
 362   ${RELOCATING+${OTHER_SYMBOLS}}
 363   ${RELOCATING+${DISCARDED}}
 364 EOF
 365
 366 # These relocations sections are part of the read-only segment in SVR4
 367 # executables, but are not mapped in BPABI executables.
 368 if [ "x$COMBRELOC" = x ]; then
 369   COMBRELOCCAT=cat
 370 else
 371   COMBRELOCCAT="cat > $COMBRELOC"
 372 fi
 373 eval $COMBRELOCCAT <<EOF
 374   .rel.init     0 : { *(.rel.init) }
 375   .rela.init    0 : { *(.rela.init) }
 376   .rel.text     0 : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
 377   .rela.text    0 : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
 378   .rel.fini     0 : { *(.rel.fini) }
 379   .rela.fini    0 : { *(.rela.fini) }
 380   .rel.rodata   0 : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }
 381   .rela.rodata  0 : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }
 382   ${OTHER_READONLY_RELOC_SECTIONS}
 383   .rel.data.rel.ro 0 : { *(.rel.data.rel.ro${RELOCATING+*}) }
 384   .rela.data.rel.ro 0 : { *(.rel.data.rel.ro${RELOCATING+*}) }
 385   .rel.data     0 : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
 386   .rela.data    0 : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
 387   .rel.tdata    0 : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 388   .rela.tdata   0 : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 389   .rel.tbss     0 : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 390   .rela.tbss    0 : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 391   .rel.ctors    0 : { *(.rel.ctors) }
 392   .rela.ctors   0 : { *(.rela.ctors) }
 393   .rel.dtors    0 : { *(.rel.dtors) }
 394   .rela.dtors   0 : { *(.rela.dtors) }
 395   ${REL_SDATA}
 396   ${REL_SBSS}
 397   ${REL_SDATA2}
 398   ${REL_SBSS2}
 399   .rel.bss      0 : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }
 400   .rela.bss     0 : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }
 401   .rel.init_array  0 : { *(.rel.init_array) }
 402   .rela.init_array 0 : { *(.rela.init_array) }
 403   .rel.fini_array  0 : { *(.rel.fini_array) }
 404   .rela.fini_array 0 : { *(.rela.fini_array) }
 405 EOF
 406 if [ -n "$COMBRELOC" ]; then
 407 cat <<EOF
 408   .rel.dyn      0 :
 409     {
 410 EOF
 411 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC
 412 cat <<EOF
 413     }
 414   .rela.dyn     0 :
 415     {
 416 EOF
 417 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC
 418 cat <<EOF
 419     }
 420 EOF
 421 fi
 422 cat <<EOF
 423   .rel.plt      0 : { *(.rel.plt) }
 424   .rela.plt     0 : { *(.rela.plt) }
 425   ${OTHER_PLT_RELOC_SECTIONS}
 426   .rel.other    0 : { *(.rel.*) }
 427   .rela.other   0 : { *(.rela.*) }
 428   .reli.other   0 : { *(.reli.*) }
 429 }
 430 EOF