ld/scripttempl/arclinux.sc

   1 #
   2 # Unusual variables checked by this code:
   3 #       NOP - four byte opcode for no-op (defaults to 0)
   4 #       NO_SMALL_DATA - no .sbss/.sbss2/.sdata/.sdata2 sections if not
   5 #               empty.
   6 #       DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
   7 #       INITIAL_READONLY_SECTIONS - at start of text segment
   8 #       OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
   9 #               (e.g., .PARISC.milli)
  10 #       OTHER_TEXT_SECTIONS - these get put in .text when relocating
  11 #       OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
  12 #               (e.g., .PARISC.global)
  13 #       OTHER_BSS_SECTIONS - other than .bss .sbss ...
  14 #       OTHER_SECTIONS - at the end
  15 #       EXECUTABLE_SYMBOLS - symbols that must be defined for an
  16 #               executable (e.g., _DYNAMIC_LINK)
  17 #       TEXT_START_SYMBOLS - symbols that appear at the start of the
  18 #               .text section.
  19 #       DATA_START_SYMBOLS - symbols that appear at the start of the
  20 #               .data section.
  21 #       OTHER_GOT_SYMBOLS - symbols defined just before .got.
  22 #       OTHER_GOT_SECTIONS - sections just after .got.
  23 #       OTHER_SDATA_SECTIONS - sections just after .sdata.
  24 #       OTHER_BSS_SYMBOLS - symbols that appear at the start of the
  25 #               .bss section besides __bss_start.
  26 #       DATA_PLT - .plt should be in data segment, not text segment.
  27 #       BSS_PLT - .plt should be in bss segment
  28 #       TEXT_DYNAMIC - .dynamic in text segment, not data segment.
  29 #       EMBEDDED - whether this is for an embedded system.
  30 #       SHLIB_TEXT_START_ADDR - if set, add to SIZEOF_HEADERS to set
  31 #               start address of shared library.
  32 #       INPUT_FILES - INPUT command of files to always include
  33 #       WRITABLE_RODATA - if set, the .rodata section should be writable
  34 #       INIT_START, INIT_END -  statements just before and just after
  35 #       combination of .init sections.
  36 #       FINI_START, FINI_END - statements just before and just after
  37 #       combination of .fini sections.
  38 #       STACK_ADDR - start of a .stack section.
  39 #       OTHER_END_SYMBOLS - symbols to place right at the end of the script.
  40 #
  41 # When adding sections, do note that the names of some sections are used
  42 # when specifying the start address of the next.
  43 #
  44
  45 #  Many sections come in three flavours.  There is the 'real' section,
  46 #  like ".data".  Then there are the per-procedure or per-variable
  47 #  sections, generated by -ffunction-sections and -fdata-sections in GCC,
  48 #  and useful for --gc-sections, which for a variable "foo" might be
  49 #  ".data.foo".  Then there are the linkonce sections, for which the linker
  50 #  eliminates duplicates, which are named like ".gnu.linkonce.d.foo".
  51 #  The exact correspondences are:
  52 #
  53 #  Section      Linkonce section
  54 #  .text        .gnu.linkonce.t.foo
  55 #  .rodata      .gnu.linkonce.r.foo
  56 #  .data        .gnu.linkonce.d.foo
  57 #  .bss         .gnu.linkonce.b.foo
  58 #  .sdata       .gnu.linkonce.s.foo
  59 #  .sbss        .gnu.linkonce.sb.foo
  60 #  .sdata2      .gnu.linkonce.s2.foo
  61 #  .sbss2       .gnu.linkonce.sb2.foo
  62 #  .debug_info  .gnu.linkonce.wi.foo
  63 #  .tdata       .gnu.linkonce.td.foo
  64 #  .tbss        .gnu.linkonce.tb.foo
  65 #
  66 #  Each of these can also have corresponding .rel.* and .rela.* sections.
  67
  68 test -z "$ENTRY" && ENTRY=start
  69 test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
  70 test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
  71 # If we request a big endian toolchain, give a big endian linker
  72 test "${ARC_ENDIAN}" == "big" && OUTPUT_FORMAT=${BIG_OUTPUT_FORMAT}
  73 if [ -z "$MACHINE" ]; then OUTPUT_ARCH=${ARCH}; else OUTPUT_ARCH=${ARCH}:${MACHINE}; fi
  74 test -z "${ELFSIZE}" && ELFSIZE=32
  75 test -z "${ALIGNMENT}" && ALIGNMENT="${ELFSIZE} / 8"
  76 test "$LD_FLAG" = "N" && DATA_ADDR=.
  77 test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
  78 test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
  79 DATA_SEGMENT_ALIGN="ALIGN(${SEGMENT_SIZE}) + (. & (${MAXPAGESIZE} - 1))"
  80 DATA_SEGMENT_END=""
  81 if test -n "${COMMONPAGESIZE}"; then
  82   DATA_SEGMENT_ALIGN="ALIGN (${SEGMENT_SIZE}) - ((${MAXPAGESIZE} - .) & (${MAXPAGESIZE} - 1)); . = DATA_SEGMENT_ALIGN (${MAXPAGESIZE}, ${COMMONPAGESIZE})"
  83   DATA_SEGMENT_END=". = DATA_SEGMENT_END (.);"
  84 fi
  85 INTERP=".interp       ${RELOCATING-0} : { *(.interp) }"
  86 PLT=".plt          ${RELOCATING-0} : { *(.plt) }"
  87 test -z "$GOT" && GOT=".got          ${RELOCATING-0} : { *(.got.plt) *(.got) }"
  88 DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
  89 RODATA=".rodata       ${RELOCATING-0} : { *(.rodata${RELOCATING+ .rodata.* .gnu.linkonce.r.*}) }"
  90 STACKNOTE="/DISCARD/ : { *(.note.GNU-stack) }"
  91 if test -z "${NO_SMALL_DATA}"; then
  92   SBSS=".sbss         ${RELOCATING-0} :
  93   {
  94     ${RELOCATING+PROVIDE (__sbss_start = .);}
  95     ${RELOCATING+PROVIDE (___sbss_start = .);}
  96     *(.dynsbss)
  97     *(.sbss${RELOCATING+ .sbss.* .gnu.linkonce.sb.*})
  98     *(.scommon)
  99     ${RELOCATING+PROVIDE (__sbss_end = .);}
 100     ${RELOCATING+PROVIDE (___sbss_end = .);}
 101   }"
 102   SBSS2=".sbss2        ${RELOCATING-0} : { *(.sbss2${RELOCATING+ .sbss2.* .gnu.linkonce.sb2.*}) }"
 103   SDATA="/* We want the small data sections together, so single-instruction offsets
 104      can access them all, and initialized data all before uninitialized, so
 105      we can shorten the on-disk segment size.  */
 106   .sdata        ${RELOCATING-0} :
 107   {
 108     ${RELOCATING+${SDATA_START_SYMBOLS}}
 109     *(.sdata${RELOCATING+ .sdata.* .gnu.linkonce.s.*})
 110   }"
 111   SDATA2=".sdata2       ${RELOCATING-0} : { *(.sdata2${RELOCATING+ .sdata2.* .gnu.linkonce.s2.*}) }"
 112   REL_SDATA=".rel.sdata    ${RELOCATING-0} : { *(.rel.sdata${RELOCATING+ .rel.sdata.* .rel.gnu.linkonce.s.*}) }
 113   .rela.sdata   ${RELOCATING-0} : { *(.rela.sdata${RELOCATING+ .rela.sdata.* .rela.gnu.linkonce.s.*}) }"
 114   REL_SBSS=".rel.sbss     ${RELOCATING-0} : { *(.rel.sbss${RELOCATING+ .rel.sbss.* .rel.gnu.linkonce.sb.*}) }
 115   .rela.sbss    ${RELOCATING-0} : { *(.rela.sbss${RELOCATING+ .rela.sbss.* .rela.gnu.linkonce.sb.*}) }"
 116   REL_SDATA2=".rel.sdata2   ${RELOCATING-0} : { *(.rel.sdata2${RELOCATING+ .rel.sdata2.* .rel.gnu.linkonce.s2.*}) }
 117   .rela.sdata2  ${RELOCATING-0} : { *(.rela.sdata2${RELOCATING+ .rela.sdata2.* .rela.gnu.linkonce.s2.*}) }"
 118   REL_SBSS2=".rel.sbss2    ${RELOCATING-0} : { *(.rel.sbss2${RELOCATING+ .rel.sbss2.* .rel.gnu.linkonce.sb2.*}) }
 119   .rela.sbss2   ${RELOCATING-0} : { *(.rela.sbss2${RELOCATING+ .rela.sbss2.* .rela.gnu.linkonce.sb2.*}) }"
 120 fi
 121 CTOR=".ctors        ${CONSTRUCTING-0} :
 122   {
 123     ${CONSTRUCTING+${CTOR_START}}
 124     /* gcc uses crtbegin.o to find the start of
 125        the constructors, so we make sure it is
 126        first.  Because this is a wildcard, it
 127        doesn't matter if the user does not
 128        actually link against crtbegin.o; the
 129        linker won't look for a file to match a
 130        wildcard.  The wildcard also means that it
 131        doesn't matter which directory crtbegin.o
 132        is in.  */
 133
 134     KEEP (*crtbegin*.o(.ctors))
 135
 136     /* We don't want to include the .ctor section from
 137        from the crtend.o file until after the sorted ctors.
 138        The .ctor section from the crtend file contains the
 139        end of ctors marker and it must be last */
 140
 141     KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .ctors))
 142     KEEP (*(SORT(.ctors.*)))
 143     KEEP (*(.ctors))
 144     ${CONSTRUCTING+${CTOR_END}}
 145   }"
 146 DTOR=".dtors        ${CONSTRUCTING-0} :
 147   {
 148     ${CONSTRUCTING+${DTOR_START}}
 149     KEEP (*crtbegin*.o(.dtors))
 150     KEEP (*(EXCLUDE_FILE (*crtend*.o $OTHER_EXCLUDE_FILES) .dtors))
 151     KEEP (*(SORT(.dtors.*)))
 152     KEEP (*(.dtors))
 153     ${CONSTRUCTING+${DTOR_END}}
 154   }"
 155 STACK="  .stack        ${RELOCATING-0}${RELOCATING+${STACK_ADDR}} :
 156   {
 157     ${RELOCATING+_stack = .;}
 158     *(.stack)
 159   }"
 160
 161 # if this is for an embedded system, don't add SIZEOF_HEADERS.
 162 if [ -z "$EMBEDDED" ]; then
 163    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR} + SIZEOF_HEADERS"
 164 else
 165    test -z "${TEXT_BASE_ADDRESS}" && TEXT_BASE_ADDRESS="${TEXT_START_ADDR}"
 166 fi
 167
 168 cat <<EOF
 169 OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
 170               "${LITTLE_OUTPUT_FORMAT}")
 171 OUTPUT_ARCH(${OUTPUT_ARCH})
 172 ${RELOCATING+ENTRY(${ENTRY})}
 173
 174 ${RELOCATING+${LIB_SEARCH_DIRS}}
 175 ${RELOCATING+/* Do we need any of these for elf?
 176    __DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}}  */}
 177 ${RELOCATING+${EXECUTABLE_SYMBOLS}}
 178 ${RELOCATING+${INPUT_FILES}}
 179 ${RELOCATING- /* For some reason, the Solaris linker makes bad executables
 180   if gld -r is used and the intermediate file has sections starting
 181   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
 182   bug.  But for now assigning the zero vmas works.  */}
 183
 184 SECTIONS
 185 {
 186   /* Read-only sections, merged into text segment: */
 187   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+PROVIDE (__executable_start = ${TEXT_START_ADDR}); . = ${TEXT_BASE_ADDRESS};}}}
 188   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
 189   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_TEXT_START_ADDR:-0} + SIZEOF_HEADERS;}}
 190   ${CREATE_SHLIB-${INTERP}}
 191   ${INITIAL_READONLY_SECTIONS}
 192   ${TEXT_DYNAMIC+${DYNAMIC}}
 193   .hash         ${RELOCATING-0} : { *(.hash) }
 194   .dynsym       ${RELOCATING-0} : { *(.dynsym) }
 195   .dynstr       ${RELOCATING-0} : { *(.dynstr) }
 196   .gnu.version  ${RELOCATING-0} : { *(.gnu.version) }
 197   .gnu.version_d ${RELOCATING-0}: { *(.gnu.version_d) }
 198   .gnu.version_r ${RELOCATING-0}: { *(.gnu.version_r) }
 199
 200 EOF
 201 if [ "x$COMBRELOC" = x ]; then
 202   COMBRELOCCAT=cat
 203 else
 204   COMBRELOCCAT="cat > $COMBRELOC"
 205 fi
 206 eval $COMBRELOCCAT <<EOF
 207   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
 208   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
 209   .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
 210   .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
 211   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
 212   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
 213   .rel.rodata   ${RELOCATING-0} : { *(.rel.rodata${RELOCATING+ .rel.rodata.* .rel.gnu.linkonce.r.*}) }
 214   .rela.rodata  ${RELOCATING-0} : { *(.rela.rodata${RELOCATING+ .rela.rodata.* .rela.gnu.linkonce.r.*}) }
 215   ${OTHER_READONLY_RELOC_SECTIONS}
 216   .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
 217   .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
 218   .rel.tdata    ${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
 219   .rela.tdata   ${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
 220   .rel.tbss     ${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
 221   .rela.tbss    ${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
 222   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
 223   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
 224   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
 225   .rela.dtors   ${RELOCATING-0} : { *(.rela.dtors) }
 226   .rel.got      ${RELOCATING-0} : { *(.rel.got) }
 227   .rela.got     ${RELOCATING-0} : { *(.rela.got) }
 228   ${OTHER_GOT_RELOC_SECTIONS}
 229   ${REL_SDATA}
 230   ${REL_SBSS}
 231   ${REL_SDATA2}
 232   ${REL_SBSS2}
 233   .rel.bss      ${RELOCATING-0} : { *(.rel.bss${RELOCATING+ .rel.bss.* .rel.gnu.linkonce.b.*}) }
 234   .rela.bss     ${RELOCATING-0} : { *(.rela.bss${RELOCATING+ .rela.bss.* .rela.gnu.linkonce.b.*}) }
 235 EOF
 236 if [ -n "$COMBRELOC" ]; then
 237 cat <<EOF
 238   .rel.dyn      ${RELOCATING-0} :
 239     {
 240 EOF
 241 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rela\./d;s/^.*: { *\(.*\)}$/      \1/' $COMBRELOC
 242 cat <<EOF
 243     }
 244   .rela.dyn     ${RELOCATING-0} :
 245     {
 246 EOF
 247 sed -e '/^[     ]*[{}][         ]*$/d;/:[       ]*$/d;/\.rel\./d;s/^.*: { *\(.*\)}/      \1/' $COMBRELOC
 248 cat <<EOF
 249     }
 250 EOF
 251 fi
 252 cat <<EOF
 253   .rel.plt      ${RELOCATING-0} : { *(.rel.plt) }
 254   .rela.plt     ${RELOCATING-0} : { *(.rela.plt) }
 255   ${OTHER_PLT_RELOC_SECTIONS}
 256
 257   .init         ${RELOCATING-0} :
 258   {
 259     ${RELOCATING+${INIT_START}}
 260     KEEP (*(.init))
 261     ${RELOCATING+${INIT_END}}
 262   } =${NOP-0}
 263
 264   ${DATA_PLT-${BSS_PLT-${PLT}}}
 265   .text         ${RELOCATING-0} :
 266   {
 267     ${RELOCATING+${TEXT_START_SYMBOLS}}
 268     *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
 269     /* .gnu.warning sections are handled specially by elf32.em.  */
 270     *(.gnu.warning)
 271     ${RELOCATING+${OTHER_TEXT_SECTIONS}}
 272   } =${NOP-0}
 273   .text.init ${RELOCATING-0} :
 274   {
 275     *(.text.init)
 276   } =${NOP-0}
 277   .fini         ${RELOCATING-0} :
 278   {
 279     ${RELOCATING+${FINI_START}}
 280     KEEP (*(.fini))
 281     ${RELOCATING+${FINI_END}}
 282   } =${NOP-0}
 283   ${RELOCATING+PROVIDE (__etext = .);}
 284   ${RELOCATING+PROVIDE (_etext = .);}
 285   ${RELOCATING+PROVIDE (etext = .);}
 286   ${WRITABLE_RODATA-${RODATA}}
 287   .rodata1      ${RELOCATING-0} : { *(.rodata1) }
 288   ${CREATE_SHLIB-${SDATA2}}
 289   ${CREATE_SHLIB-${SBSS2}}
 290   ${OTHER_READONLY_SECTIONS}
 291   .eh_frame_hdr : { *(.eh_frame_hdr) }
 292
 293   /* Adjust the address for the data segment.  We want to adjust up to
 294      the same address within the page on the next page up.  */
 295   ${CREATE_SHLIB-${CREATE_PIE-${RELOCATING+. = ${DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}}
 296   ${CREATE_SHLIB+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 297   ${CREATE_PIE+${RELOCATING+. = ${SHLIB_DATA_ADDR-${DATA_SEGMENT_ALIGN}};}}
 298
 299   /* Ensure the __preinit_array_start label is properly aligned.  We
 300      could instead move the label definition inside the section, but
 301      the linker would then create the section even if it turns out to
 302      be empty, which isn't pretty.  */
 303   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 304   ${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_start = .);}}
 305   .preinit_array   ${RELOCATING-0} : { *(.preinit_array) }
 306   ${RELOCATING+${CREATE_SHLIB-PROVIDE (__preinit_array_end = .);}}
 307
 308   ${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_start = .);}}
 309   .init_array   ${RELOCATING-0} : { *(.init_array) }
 310   ${RELOCATING+${CREATE_SHLIB-PROVIDE (__init_array_end = .);}}
 311
 312   ${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_start = .);}}
 313   .fini_array   ${RELOCATING-0} : { *(.fini_array) }
 314   ${RELOCATING+${CREATE_SHLIB-PROVIDE (__fini_array_end = .);}}
 315
 316   .data         ${RELOCATING-0} :
 317   {
 318     ${RELOCATING+${DATA_START_SYMBOLS}}
 319     *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
 320     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
 321   }
 322   .data.init  ${RELOCATING-0} :
 323   {
 324     *(.data.init)
 325   }
 326   .data1        ${RELOCATING-0} : { *(.data1) }
 327   /* TLS local dynamic uses .tdata as a reference point.  */
 328   ${RELOCATING+${CREATE_SHLIB+PROVIDE_HIDDEN (.tdata = .);}}
 329   .tdata        ${RELOCATING-0} : { *(.tdata${RELOCATING+ .tdata.* .gnu.linkonce.td.*}) }
 330   .tbss         ${RELOCATING-0} : { *(.tbss${RELOCATING+ .tbss.* .gnu.linkonce.tb.*})${RELOCATING+ *(.tcommon)} }
 331   .eh_frame     ${RELOCATING-0} : { KEEP (*(.eh_frame)) }
 332   .gcc_except_table ${RELOCATING-0} : { *(.gcc_except_table) }
 333   ${WRITABLE_RODATA+${RODATA}}
 334   ${OTHER_READWRITE_SECTIONS}
 335   ${TEXT_DYNAMIC-${DYNAMIC}}
 336   ${RELOCATING+${CTOR}}
 337   ${RELOCATING+${DTOR}}
 338   .jcr          ${RELOCATING-0} : { KEEP (*(.jcr)) }
 339   ${DATA_PLT+${PLT}}
 340   ${RELOCATING+${OTHER_GOT_SYMBOLS}}
 341   ${GOT}
 342   ${OTHER_GOT_SECTIONS}
 343   ${CREATE_SHLIB+${SDATA2}}
 344   ${CREATE_SHLIB+${SBSS2}}
 345   ${SDATA}
 346   ${OTHER_SDATA_SECTIONS}
 347   ${RELOCATING+_edata = .;}
 348   ${RELOCATING+PROVIDE (edata = .);}
 349   ${RELOCATING+__bss_start = .;}
 350   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
 351   ${SBSS}
 352   ${BSS_PLT+${PLT}}
 353   .bss          ${RELOCATING-0} :
 354   {
 355    *(.dynbss)
 356    *(.bss${RELOCATING+ .bss.* .gnu.linkonce.b.*})
 357    *(COMMON)
 358    /* Align here to ensure that the .bss section occupies space up to
 359       _end.  Align after .bss to ensure correct alignment even if the
 360       .bss section disappears because there are no input sections.  */
 361    ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 362   }
 363   ${OTHER_BSS_SECTIONS}
 364   ${RELOCATING+. = ALIGN(${ALIGNMENT});}
 365   ${RELOCATING+_end = .;}
 366   ${RELOCATING+${OTHER_BSS_END_SYMBOLS}}
 367   ${RELOCATING+PROVIDE (end = .);}
 368   ${RELOCATING+${DATA_SEGMENT_END}}
 369
 370   /* We want to be able to set a default stack / heap size in a dejagnu
 371      board description file, but override it for selected test cases.
 372      The options appear in the wrong order to do this with a single symbol -
 373      ldflags comes after flags injected with per-file stanzas, and thus
 374      the setting from ldflags prevails.  */
 375   .heap ${RELOCATING-0} :
 376   {
 377         ${RELOCATING+ __start_heap = . ; }
 378         ${RELOCATING+ . = . + (DEFINED(__HEAP_SIZE) ? __HEAP_SIZE : (DEFINED(__DEFAULT_HEAP_SIZE) ? __DEFAULT_HEAP_SIZE : 20k))  ; }
 379         ${RELOCATING+ __end_heap = . ; }
 380   }
 381
 382   ${RELOCATING+. = ALIGN(0x8);}
 383   .stack ${RELOCATING-0} :
 384   {
 385         ${RELOCATING+ __stack = . ; }
 386         ${RELOCATING+ . = . + (DEFINED(__STACK_SIZE) ? __STACK_SIZE : (DEFINED(__DEFAULT_STACK_SIZE) ? __DEFAULT_STACK_SIZE : 64k))  ; }
 387         ${RELOCATING+ __stack_top = . ; }
 388   }
 389
 390   /* Stabs debugging sections.  */
 391   .stab          0 : { *(.stab) }
 392   .stabstr       0 : { *(.stabstr) }
 393   .stab.excl     0 : { *(.stab.excl) }
 394   .stab.exclstr  0 : { *(.stab.exclstr) }
 395   .stab.index    0 : { *(.stab.index) }
 396   .stab.indexstr 0 : { *(.stab.indexstr) }
 397
 398   .comment       0 : { *(.comment) }
 399
 400   /* DWARF debug sections.
 401      Symbols in the DWARF debugging sections are relative to the beginning
 402      of the section so we begin them at 0.  */
 403
 404   /* DWARF 1 */
 405   .debug          0 : { *(.debug) }
 406   .line           0 : { *(.line) }
 407
 408   /* GNU DWARF 1 extensions */
 409   .debug_srcinfo  0 : { *(.debug_srcinfo) }
 410   .debug_sfnames  0 : { *(.debug_sfnames) }
 411
 412   /* DWARF 1.1 and DWARF 2 */
 413   .debug_aranges  0 : { *(.debug_aranges) }
 414   .debug_pubnames 0 : { *(.debug_pubnames) }
 415
 416   /* DWARF 2 */
 417   .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
 418   .debug_abbrev   0 : { *(.debug_abbrev) }
 419   .debug_line     0 : { *(.debug_line) }
 420   .debug_frame    0 : { *(.debug_frame) }
 421   .debug_str      0 : { *(.debug_str) }
 422   .debug_loc      0 : { *(.debug_loc) }
 423   .debug_macinfo  0 : { *(.debug_macinfo) }
 424
 425   /* SGI/MIPS DWARF 2 extensions */
 426   .debug_weaknames 0 : { *(.debug_weaknames) }
 427   .debug_funcnames 0 : { *(.debug_funcnames) }
 428   .debug_typenames 0 : { *(.debug_typenames) }
 429   .debug_varnames  0 : { *(.debug_varnames) }
 430
 431   /* ARC Extension Sections */
 432   .arcextmap      0 : { *(.gnu.linkonce.arcextmap.*) }
 433
 434   ${STACK_ADDR+${STACK}}
 435   ${OTHER_SECTIONS}
 436   ${RELOCATING+${OTHER_END_SYMBOLS}}
 437   ${RELOCATING+${STACKNOTE}}
 438 }
 439 EOF