This is the mail archive of the binutils@sourceware.org mailing list for the binutils project.

Index Nav:	[Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:	[Date Prev] [Date Next]	[Thread Prev] [Thread Next]
Other format:	[Raw text]

[PATCH] Incremental merge for ppc-vx6

From: Douglas B Rupp <rupp at adacore dot com>
To: Binutils <binutils at sourceware dot org>
Cc: Alan Modra <amodra at gmail dot com>
Date: Mon, 22 Oct 2018 12:09:38 -0700
Subject: [PATCH] Incremental merge for ppc-vx6

This patch implements merging of sections created by -ffunction-sectionsand -fdata-sections on ppc-vx6.

If the sections are not merged, gdb malfunctions when printing theaddress of a runtime symbol.

The problem can be fixed in gdb (but not easily) for the WTX protocolused for older vxworks targets but not for newer vxworks (e.g. vxworks7)because the protocol is different and not under gdb control.

Future patch submissions will make use of this merge capability forother vxworks6 targets, and also vxworks7 ports

Tested on x86-linux, and also locally tested on ppc-vx6 using theAdaCore cross-testsuite.


I don't have write access, so if approved please apply when convenient.

--Douglas Rupp

2018-10-22  Douglas B Rupp  <rupp@adacore.com>
            on behalf of Jerome Guitton (guitton@adacore.com)

	ld/
	* scripttempl/elf.sc: Use MERGE_SECTIONS instead of RELOCATING as
	a condition to add per function/data and linkonce sections in the
	general section (e.g. wether or not put .rodata.* in .rodata).
	Document INCREMENTAL_MERGE.
	Define MERGE_SECTIONS if either RELOCATING or INCREMENTAL_MERGE
	is defined.
	* emulparams/elf32ppcvxworks.sh: Set INCREMENTAL_MERGE

diff --git ld/emulparams/elf32ppcvxworks.sh ld/emulparams/elf32ppcvxworks.sh
index 9b416d9..25ba550 100644
--- ld/emulparams/elf32ppcvxworks.sh
+++ ld/emulparams/elf32ppcvxworks.sh
@@ -3,4 +3,5 @@
 EXTRA_EM_FILE=ppc32elf
 OUTPUT_FORMAT="elf32-powerpc-vxworks"
 WRITABLE_SDATA2=
+INCREMENTAL_MERGE="yes"
 . ${srcdir}/emulparams/vxworks.sh
diff --git ld/scripttempl/elf.sc ld/scripttempl/elf.sc
index d2e9f1d..7f69ea1 100644
--- ld/scripttempl/elf.sc
+++ ld/scripttempl/elf.sc
@@ -71,6 +71,8 @@
 #		the number of bytes in the beginning of .got.plt which can be
 #		in the RELRO area as well.
 #	USER_LABEL_PREFIX - prefix to add to user-visible symbols.
+#	INCREMENTAL_MERGE - if set, an incremental link (-r) merge
+#		per functions/data and linkonce sections.
 #	RODATA_NAME, SDATA_NAME, SBSS_NAME, BSS_NAME - base parts of names
 #		for standard sections, without initial "." or suffixes.
 #
@@ -124,6 +126,11 @@ test "$LD_FLAG" = "N" && DATA_ADDR=.
 test -z "${ETEXT_NAME}" && ETEXT_NAME=${USER_LABEL_PREFIX}etext
 test -n "$RELRO_NOW" && unset SEPARATE_GOTPLT
 test -z "$ATTRS_SECTIONS" && ATTRS_SECTIONS=".gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }"
+if [ -n "$RELOCATING" ]; then
+   MERGE_SECTIONS=""
+else
+   test -n "$INCREMENTAL_MERGE" && MERGE_SECTIONS=""
+fi
 if test -z "$DATA_SEGMENT_ALIGN"; then
   test -n "$CREATE_SHLIB$CREATE_PIE" && test -n "$SHLIB_DATA_ADDR" && COMMONPAGESIZE=""
   test -z "$CREATE_SHLIB$CREATE_PIE" && test -n "$DATA_ADDR" && COMMONPAGESIZE=""
@@ -172,7 +179,7 @@ RELA_IPLT=".rela.iplt    ${RELOCATING-0} :
       ${RELOCATING+${CREATE_SHLIB-PROVIDE_HIDDEN (${USER_LABEL_PREFIX}__rela_iplt_end = .);}}
     }"
 DYNAMIC=".dynamic      ${RELOCATING-0} : { *(.dynamic) }"
-RODATA=".${RODATA_NAME}       ${RELOCATING-0} : { *(.${RODATA_NAME}${RELOCATING+ .${RODATA_NAME}.* .gnu.linkonce.r.*}) }"
+RODATA=".${RODATA_NAME}       ${RELOCATING-0} : { *(.${RODATA_NAME}${MERGE_SECTIONS+ .${RODATA_NAME}.* .gnu.linkonce.r.*}) }"
 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.*) }"
 DISCARDED="/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }"
 if test -z "${NO_SMALL_DATA}"; then
@@ -181,11 +188,11 @@ if test -z "${NO_SMALL_DATA}"; then
     ${RELOCATING+${SBSS_START_SYMBOLS}}
     ${CREATE_SHLIB+*(.${SBSS_NAME}2 .${SBSS_NAME}2.* .gnu.linkonce.sb2.*)}
     ${RELOCATING+*(.dyn${SBSS_NAME})}
-    *(.${SBSS_NAME}${RELOCATING+ .${SBSS_NAME}.* .gnu.linkonce.sb.*})
+    *(.${SBSS_NAME}${MERGE_SECTIONS+ .${SBSS_NAME}.* .gnu.linkonce.sb.*})
     ${RELOCATING+*(.scommon)}
     ${RELOCATING+${SBSS_END_SYMBOLS}}
   }"
-  SBSS2=".${SBSS_NAME}2        ${RELOCATING-0} : { *(.${SBSS_NAME}2${RELOCATING+ .${SBSS_NAME}2.* .gnu.linkonce.sb2.*}) }"
+  SBSS2=".${SBSS_NAME}2        ${RELOCATING-0} : { *(.${SBSS_NAME}2${MERGE_SECTIONS+ .${SBSS_NAME}2.* .gnu.linkonce.sb2.*}) }"
   SDATA="/* We want the small data sections together, so single-instruction offsets
      can access them all, and initialized data all before uninitialized, so
      we can shorten the on-disk segment size.  */
@@ -193,21 +200,21 @@ if test -z "${NO_SMALL_DATA}"; then
   {
     ${RELOCATING+${SDATA_START_SYMBOLS}}
     ${CREATE_SHLIB+*(.${SDATA_NAME}2 .${SDATA_NAME}2.* .gnu.linkonce.s2.*)}
-    *(.${SDATA_NAME}${RELOCATING+ .${SDATA_NAME}.* .gnu.linkonce.s.*})
+    *(.${SDATA_NAME}${MERGE_SECTIONS+ .${SDATA_NAME}.* .gnu.linkonce.s.*})
   }"
   SDATA2=".${SDATA_NAME}2       ${RELOCATING-0} :
   {
     ${RELOCATING+${SDATA2_START_SYMBOLS}}
-    *(.${SDATA_NAME}2${RELOCATING+ .${SDATA_NAME}2.* .gnu.linkonce.s2.*})
+    *(.${SDATA_NAME}2${MERGE_SECTIONS+ .${SDATA_NAME}2.* .gnu.linkonce.s2.*})
   }"
-  REL_SDATA=".rel.${SDATA_NAME}    ${RELOCATING-0} : { *(.rel.${SDATA_NAME}${RELOCATING+ .rel.${SDATA_NAME}.* .rel.gnu.linkonce.s.*}) }
-  .rela.${SDATA_NAME}   ${RELOCATING-0} : { *(.rela.${SDATA_NAME}${RELOCATING+ .rela.${SDATA_NAME}.* .rela.gnu.linkonce.s.*}) }"
-  REL_SBSS=".rel.${SBSS_NAME}     ${RELOCATING-0} : { *(.rel.${SBSS_NAME}${RELOCATING+ .rel.${SBSS_NAME}.* .rel.gnu.linkonce.sb.*}) }
-  .rela.${SBSS_NAME}    ${RELOCATING-0} : { *(.rela.${SBSS_NAME}${RELOCATING+ .rela.${SBSS_NAME}.* .rela.gnu.linkonce.sb.*}) }"
-  REL_SDATA2=".rel.${SDATA_NAME}2   ${RELOCATING-0} : { *(.rel.${SDATA_NAME}2${RELOCATING+ .rel.${SDATA_NAME}2.* .rel.gnu.linkonce.s2.*}) }
-  .rela.${SDATA_NAME}2  ${RELOCATING-0} : { *(.rela.${SDATA_NAME}2${RELOCATING+ .rela.${SDATA_NAME}2.* .rela.gnu.linkonce.s2.*}) }"
-  REL_SBSS2=".rel.${SBSS_NAME}2    ${RELOCATING-0} : { *(.rel.${SBSS_NAME}2${RELOCATING+ .rel.${SBSS_NAME}2.* .rel.gnu.linkonce.sb2.*}) }
-  .rela.${SBSS_NAME}2   ${RELOCATING-0} : { *(.rela.${SBSS_NAME}2${RELOCATING+ .rela.${SBSS_NAME}2.* .rela.gnu.linkonce.sb2.*}) }"
+  REL_SDATA=".rel.${SDATA_NAME}    ${RELOCATING-0} : { *(.rel.${SDATA_NAME}${MERGE_SECTIONS+ .rel.${SDATA_NAME}.* .rel.gnu.linkonce.s.*}) }
+  .rela.${SDATA_NAME}   ${RELOCATING-0} : { *(.rela.${SDATA_NAME}${MERGE_SECTIONS+ .rela.${SDATA_NAME}.* .rela.gnu.linkonce.s.*}) }"
+  REL_SBSS=".rel.${SBSS_NAME}     ${RELOCATING-0} : { *(.rel.${SBSS_NAME}${MERGE_SECTIONS+ .rel.${SBSS_NAME}.* .rel.gnu.linkonce.sb.*}) }
+  .rela.${SBSS_NAME}    ${RELOCATING-0} : { *(.rela.${SBSS_NAME}${MERGE_SECTIONS+ .rela.${SBSS_NAME}.* .rela.gnu.linkonce.sb.*}) }"
+  REL_SDATA2=".rel.${SDATA_NAME}2   ${RELOCATING-0} : { *(.rel.${SDATA_NAME}2${MERGE_SECTIONS+ .rel.${SDATA_NAME}2.* .rel.gnu.linkonce.s2.*}) }
+  .rela.${SDATA_NAME}2  ${RELOCATING-0} : { *(.rela.${SDATA_NAME}2${MERGE_SECTIONS+ .rela.${SDATA_NAME}2.* .rela.gnu.linkonce.s2.*}) }"
+  REL_SBSS2=".rel.${SBSS_NAME}2    ${RELOCATING-0} : { *(.rel.${SBSS_NAME}2${MERGE_SECTIONS+ .rel.${SBSS_NAME}2.* .rel.gnu.linkonce.sb2.*}) }
+  .rela.${SBSS_NAME}2   ${RELOCATING-0} : { *(.rela.${SBSS_NAME}2${MERGE_SECTIONS+ .rela.${SBSS_NAME}2.* .rela.gnu.linkonce.sb2.*}) }"
 else
   NO_SMALL_DATA=" "
 fi
@@ -223,23 +230,23 @@ if test -z "${SDATA_GOT}${DATA_GOT}"; then
 fi
 test -n "$SEPARATE_GOTPLT" && SEPARATE_GOTPLT=" "
 test "${LARGE_SECTIONS}" = "yes" && REL_LARGE="
-  .rel.ldata    ${RELOCATING-0} : { *(.rel.ldata${RELOCATING+ .rel.ldata.* .rel.gnu.linkonce.l.*}) }
-  .rela.ldata   ${RELOCATING-0} : { *(.rela.ldata${RELOCATING+ .rela.ldata.* .rela.gnu.linkonce.l.*}) }
-  .rel.lbss     ${RELOCATING-0} : { *(.rel.lbss${RELOCATING+ .rel.lbss.* .rel.gnu.linkonce.lb.*}) }
-  .rela.lbss    ${RELOCATING-0} : { *(.rela.lbss${RELOCATING+ .rela.lbss.* .rela.gnu.linkonce.lb.*}) }
-  .rel.lrodata  ${RELOCATING-0} : { *(.rel.lrodata${RELOCATING+ .rel.lrodata.* .rel.gnu.linkonce.lr.*}) }
-  .rela.lrodata ${RELOCATING-0} : { *(.rela.lrodata${RELOCATING+ .rela.lrodata.* .rela.gnu.linkonce.lr.*}) }"
+ .rel.ldata    ${RELOCATING-0} : { *(.rel.ldata${MERGE_SECTIONS+ .rel.ldata.* .rel.gnu.linkonce.l.*}) }
+ .rela.ldata   ${RELOCATING-0} : { *(.rela.ldata${MERGE_SECTIONS+ .rela.ldata.* .rela.gnu.linkonce.l.*}) }
+ .rel.lbss     ${RELOCATING-0} : { *(.rel.lbss${MERGE_SECTIONS+ .rel.lbss.* .rel.gnu.linkonce.lb.*}) }
+ .rela.lbss    ${RELOCATING-0} : { *(.rela.lbss${MERGE_SECTIONS+ .rela.lbss.* .rela.gnu.linkonce.lb.*}) }
+ .rel.lrodata  ${RELOCATING-0} : { *(.rel.lrodata${MERGE_SECTIONS+ .rel.lrodata.* .rel.gnu.linkonce.lr.*}) }
+ .rela.lrodata ${RELOCATING-0} : { *(.rela.lrodata${MERGE_SECTIONS+ .rela.lrodata.* .rela.gnu.linkonce.lr.*}) }"
 test "${LARGE_SECTIONS}" = "yes" && LARGE_BSS="
   .lbss ${RELOCATING-0} :
   {
     ${RELOCATING+*(.dynlbss)}
-    *(.lbss${RELOCATING+ .lbss.* .gnu.linkonce.lb.*})
+    *(.lbss${MERGE_SECTIONS+ .lbss.* .gnu.linkonce.lb.*})
     ${RELOCATING+*(LARGE_COMMON)}
   }"
 test "${LARGE_SECTIONS}" = "yes" && LARGE_SECTIONS="
   .lrodata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
   {
-    *(.lrodata${RELOCATING+ .lrodata.* .gnu.linkonce.lr.*})
+    *(.lrodata${MERGE_SECTIONS+ .lrodata.* .gnu.linkonce.lr.*})
   }
   .ldata ${RELOCATING-0} ${RELOCATING+ALIGN(${MAXPAGESIZE}) + (. & (${MAXPAGESIZE} - 1))} :
   {
@@ -407,22 +414,22 @@ eval $COMBRELOCCAT <<EOF
   ${INITIAL_RELOC_SECTIONS}
   .rel.init     ${RELOCATING-0} : { *(.rel.init) }
   .rela.init    ${RELOCATING-0} : { *(.rela.init) }
-  .rel.text     ${RELOCATING-0} : { *(.rel.text${RELOCATING+ .rel.text.* .rel.gnu.linkonce.t.*}) }
-  .rela.text    ${RELOCATING-0} : { *(.rela.text${RELOCATING+ .rela.text.* .rela.gnu.linkonce.t.*}) }
+  .rel.text     ${RELOCATING-0} : { *(.rel.text${MERGE_SECTIONS+ .rel.text.* .rel.gnu.linkonce.t.*}) }
+  .rela.text    ${RELOCATING-0} : { *(.rela.text${MERGE_SECTIONS+ .rela.text.* .rela.gnu.linkonce.t.*}) }
   .rel.fini     ${RELOCATING-0} : { *(.rel.fini) }
   .rela.fini    ${RELOCATING-0} : { *(.rela.fini) }
-  .rel.${RODATA_NAME}   ${RELOCATING-0} : { *(.rel.${RODATA_NAME}${RELOCATING+ .rel.${RODATA_NAME}.* .rel.gnu.linkonce.r.*}) }
-  .rela.${RODATA_NAME}  ${RELOCATING-0} : { *(.rela.${RODATA_NAME}${RELOCATING+ .rela.${RODATA_NAME}.* .rela.gnu.linkonce.r.*}) }
+  .rel.${RODATA_NAME}   ${RELOCATING-0} : { *(.rel.${RODATA_NAME}${MERGE_SECTIONS+ .rel.${RODATA_NAME}.* .rel.gnu.linkonce.r.*}) }
+  .rela.${RODATA_NAME}  ${RELOCATING-0} : { *(.rela.${RODATA_NAME}${MERGE_SECTIONS+ .rela.${RODATA_NAME}.* .rela.gnu.linkonce.r.*}) }
   ${OTHER_READONLY_RELOC_SECTIONS}
-  .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${RELOCATING+ .rel.data.rel.ro.* .rel.gnu.linkonce.d.rel.ro.*}) }
-  .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${RELOCATING+ .rela.data.rel.ro.* .rela.gnu.linkonce.d.rel.ro.*}) }
-  .rel.data     ${RELOCATING-0} : { *(.rel.data${RELOCATING+ .rel.data.* .rel.gnu.linkonce.d.*}) }
-  .rela.data    ${RELOCATING-0} : { *(.rela.data${RELOCATING+ .rela.data.* .rela.gnu.linkonce.d.*}) }
+  .rel.data.rel.ro ${RELOCATING-0} : { *(.rel.data.rel.ro${MERGE_SECTIONS+ .rel.data.rel.ro.* .rel.gnu.linkonce.d.rel.ro.*}) }
+  .rela.data.rel.ro ${RELOCATING-0} : { *(.rela.data.rel.ro${MERGE_SECTIONS+ .rela.data.rel.ro.* .rela.gnu.linkonce.d.rel.ro.*}) }
+  .rel.data     ${RELOCATING-0} : { *(.rel.data${MERGE_SECTIONS+ .rel.data.* .rel.gnu.linkonce.d.*}) }
+  .rela.data    ${RELOCATING-0} : { *(.rela.data${MERGE_SECTIONS+ .rela.data.* .rela.gnu.linkonce.d.*}) }
   ${OTHER_READWRITE_RELOC_SECTIONS}
-  .rel.tdata	${RELOCATING-0} : { *(.rel.tdata${RELOCATING+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
-  .rela.tdata	${RELOCATING-0} : { *(.rela.tdata${RELOCATING+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
-  .rel.tbss	${RELOCATING-0} : { *(.rel.tbss${RELOCATING+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
-  .rela.tbss	${RELOCATING-0} : { *(.rela.tbss${RELOCATING+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
+  .rel.tdata	${RELOCATING-0} : { *(.rel.tdata${MERGE_SECTIONS+ .rel.tdata.* .rel.gnu.linkonce.td.*}) }
+  .rela.tdata	${RELOCATING-0} : { *(.rela.tdata${MERGE_SECTIONS+ .rela.tdata.* .rela.gnu.linkonce.td.*}) }
+  .rel.tbss	${RELOCATING-0} : { *(.rel.tbss${MERGE_SECTIONS+ .rel.tbss.* .rel.gnu.linkonce.tb.*}) }
+  .rela.tbss	${RELOCATING-0} : { *(.rela.tbss${MERGE_SECTIONS+ .rela.tbss.* .rela.gnu.linkonce.tb.*}) }
   .rel.ctors    ${RELOCATING-0} : { *(.rel.ctors) }
   .rela.ctors   ${RELOCATING-0} : { *(.rela.ctors) }
   .rel.dtors    ${RELOCATING-0} : { *(.rel.dtors) }
@@ -434,8 +441,8 @@ eval $COMBRELOCCAT <<EOF
   ${REL_SBSS}
   ${REL_SDATA2}
   ${REL_SBSS2}
-  .rel.${BSS_NAME}      ${RELOCATING-0} : { *(.rel.${BSS_NAME}${RELOCATING+ .rel.${BSS_NAME}.* .rel.gnu.linkonce.b.*}) }
-  .rela.${BSS_NAME}     ${RELOCATING-0} : { *(.rela.${BSS_NAME}${RELOCATING+ .rela.${BSS_NAME}.* .rela.gnu.linkonce.b.*}) }
+  .rel.${BSS_NAME}      ${RELOCATING-0} : { *(.rel.${BSS_NAME}${MERGE_SECTIONS+ .rel.${BSS_NAME}.* .rel.gnu.linkonce.b.*}) }
+  .rela.${BSS_NAME}     ${RELOCATING-0} : { *(.rela.${BSS_NAME}${MERGE_SECTIONS+ .rela.${BSS_NAME}.* .rela.gnu.linkonce.b.*}) }
   ${REL_LARGE}
   ${IREL_IN_PLT+$REL_IFUNC}
   ${IREL_IN_PLT+$RELA_IFUNC}
@@ -514,10 +521,10 @@ cat <<EOF
     ${RELOCATING+*(.text.exit .text.exit.*)}
     ${RELOCATING+*(.text.startup .text.startup.*)}
     ${RELOCATING+*(.text.hot .text.hot.*)}
-    *(.text .stub${RELOCATING+ .text.* .gnu.linkonce.t.*})
+    *(.text .stub${MERGE_SECTIONS+ .text.* .gnu.linkonce.t.*})
     /* .gnu.warning sections are handled specially by elf32.em.  */
     *(.gnu.warning)
-    ${RELOCATING+${OTHER_TEXT_SECTIONS}}
+    ${MERGE_SECTIONS+${OTHER_TEXT_SECTIONS}}
   } ${FILL}
   .fini         ${RELOCATING-0}${RELOCATING+${FINI_ADDR}} :
   {
@@ -622,7 +629,7 @@ cat <<EOF
   .data         ${RELOCATING-0} :
   {
     ${RELOCATING+${DATA_START_SYMBOLS}}
-    *(.data${RELOCATING+ .data.* .gnu.linkonce.d.*})
+    *(.data${MERGE_SECTIONS+ .data.* .gnu.linkonce.d.*})
     ${CONSTRUCTING+SORT(CONSTRUCTORS)}
   }
   .data1        ${RELOCATING-0} : { *(.data1) }
@@ -647,7 +654,7 @@ cat <<EOF
   .${BSS_NAME}          ${RELOCATING-0} :
   {
    ${RELOCATING+*(.dynbss)}
-   *(.${BSS_NAME}${RELOCATING+ .${BSS_NAME}.* .gnu.linkonce.b.*})
+   *(.${BSS_NAME}${MERGE_SECTIONS+ .${BSS_NAME}.* .gnu.linkonce.b.*})
    ${RELOCATING+*(COMMON)
    /* Align here to ensure that the .bss section occupies space up to
       _end.  Align after .bss to ensure correct alignment even if the

Follow-Ups:
- Re: [PATCH] Incremental merge for ppc-vx6
  - From: Alan Modra

Index Nav:	[Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:	[Date Prev] [Date Next]	[Thread Prev] [Thread Next]