[PATCH] Support SHF_GNU_RETAIN ELF section flag

[PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

[-- Attachment #1: Type: text/plain, Size: 2653 bytes --]

The attached patch adds support for the new SHF_GNU_RETAIN ELF section
flag, which was discussed on the GNU gABI mailing list here:
https://sourceware.org/pipermail/gnu-gabi/2020q3/000429.html

The flag is GNU-specific so uses a bit in the SHF_MASKOS mask.
Its precise definition is as follows:

=======================================================================
Section Attribute Flags
+-------------------------------------+
| Name           | Value              |
+-------------------------------------+
| SHF_GNU_RETAIN | 0x200000 (1 << 21) |
+-------------------------------------+

SHF_GNU_RETAIN
  The link editor should not garbage collect the section if it is
  unused.

=======================================================================

The overall intention for this new flag is to enable a new "retain"
attribute to be applied to declarations of functions and data in the
source code. This attribute can be used to ensure the definition
associated with the declaration is present in the linked output file,
even if linker garbage collection would normally remove the containing
section because it is unused.

The new ".retain" assembler directive can be used to apply
SHF_GNU_RETAIN to a section. GCC will emit this directive when
assembling definitions of functions and data that have had the "retain"
attribute applied.

Note that there is *not* a direct mapping of SHF_GNU_RETAIN to the BFD
section flag SEC_KEEP. SEC_KEEP would prevent the user being able to
explicitly remove an SHF_GNU_RETAIN section by placing it in /DISCARD/,
which could be necessary in some situations.

I successfully regtested the patch for the Binutils, GAS and LD
testsuites for the following CPUs, applying the "-elf" suffix when
configuring:
  aarch64 alpha arc arm avr bfin bpf cr16 cris crx csky d10v d30v dlx
  epiphany fr30 frv ft32 h8300 hppa i386 ia64 ia64-vms ip2k iq2000 lm32
  m32c m32r m68hc11 m68hc12 m68k mcore mep metag microblaze mips mmix
  moxie msp430 mt nds32 nfp nios2 or1k pj ppc pru riscv rl78 rx s12z
  s390 score sh sparc spu tic6x tilegx tilepro v850 vax visium wasm32
  x86-64 x86 xc16x xgate xstormy16 xtensa z80

The new tests are passing for all targets except mmix-elf. This target
has a lot of LD failures, particularly --gc-sections doesn't appear to
have any effect. I don't know anything about the target, but I wonder if
it should be added to the hard-coded list of targets that doesn't
support --gc-sections.  I have therefore XFAIL'd the new LD tests for
this target.

I also regtested for i386-pe, to ensure there was no spill-over of the
new functionality into any non-ELF areas.

Ok to apply?

Thanks,
Jozef

[-- Attachment #2: 0001-Support-SHF_GNU_RETAIN-ELF-section-flag.patch --]
[-- Type: text/plain, Size: 41226 bytes --]

From d7f92cd05883567cf07cb8878aa60b666894197d Mon Sep 17 00:00:00 2001
From: Jozef Lawrynowicz <jozef.l@mittosystems.com>
Date: Tue, 22 Sep 2020 21:00:35 +0100
Subject: [PATCH] Support SHF_GNU_RETAIN ELF section flag

The GNU-specific SHF_GNU_RETAIN ELF section flag is defined as follows:

=======================================================================
Section Attribute Flags
+-------------------------------------+
| Name           | Value              |
+-------------------------------------+
| SHF_GNU_RETAIN | 0x200000 (1 << 21) |
+-------------------------------------+

SHF_GNU_RETAIN
  The link editor should not garbage collect the section if it is
  unused.

=======================================================================

The new ".retain" assembler directive can be used to apply
SHF_GNU_RETAIN to a section.

Note that there is not a direct mapping of SHF_GNU_RETAIN to the BFD
section flag SEC_KEEP. This would prevent the user being able to
explicitly remove an SHF_GNU_RETAIN section by placing it in /DISCARD/.

bfd/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* elflink.c (bfd_elf_gc_sections): gc_mark the section if
	SHF_GNU_RETAIN is set.

binutils/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* NEWS: Announce SHF_GNU_RETAIN.
	* readelf.c (get_elf_section_flags): Handle SHF_GNU_RETAIN.
	* testsuite/binutils-all/readelf.exp: Run new test.
	Don't run run_dump_test when there isn't an assembler available.
	* testsuite/binutils-all/retain1.d: New test.
	* testsuite/binutils-all/retain1.s: New test.

gas/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* NEWS: Announce .retain directive and SHF_GNU_RETAIN.
	* config/obj-elf.c (elf_pseudo_table): Add "retain".
	(obj_elf_retain): New.
	(obj_elf_parse_section_letters): Handle 'R' flag.
	* doc/as.texi: Document .retain directive.
	(Section): Document 'R' flag.
	* testsuite/gas/elf/elf.exp: Run new tests.
	* testsuite/gas/elf/retain1.d: New test.
	* testsuite/gas/elf/retain1.s: New test.
	* testsuite/gas/elf/retain2.d: New test.
	* testsuite/gas/elf/retain2.l: New test.
	* testsuite/gas/elf/retain2.s: New test.
	* testsuite/gas/elf/retain3.d: New test.
	* testsuite/gas/elf/retain3.s: New test.
	* testsuite/gas/elf/section10.d: Adjust test.

include/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* elf/common.h (SHF_GNU_RETAIN): Define.

ld/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* NEWS: Announce SHF_GNU_RETAIN.
	* ld.texi (garbage collection): Document SHF_GNU_RETAIN.
	(Output Section Discarding): Likewise.
	* testsuite/ld-elf/elf.exp: Run new tests.
	* testsuite/ld-elf/retain1.msg: New test.
	* testsuite/ld-elf/retain1.s: New test.
	* testsuite/ld-elf/retain2.d: New test.
	* testsuite/ld-elf/retain2.ld: New test.
	* testsuite/ld-elf/retain2.map: New test.
	* testsuite/ld-elf/retain3.msg: New test.
	* testsuite/ld-elf/retain3.s: New test.
	* testsuite/ld-elf/retain4.s: New test.
	* testsuite/ld-elf/retain5.s: New test.
	* testsuite/ld-elf/retain6lib.s: New test.
	* testsuite/ld-elf/retain6main.s: New test.
	* testsuite/ld-elf/retain7.msg: New test.
	* testsuite/ld-elf/retain7lib.s: New test.
	* testsuite/ld-elf/retain7main.s: New test.
---
 bfd/elflink.c                               |   3 +-
 binutils/NEWS                               |   4 +
 binutils/readelf.c                          |   4 +
 binutils/testsuite/binutils-all/readelf.exp |   6 +-
 binutils/testsuite/binutils-all/retain1.d   |  17 +++
 binutils/testsuite/binutils-all/retain1.s   | 114 ++++++++++++++++++++
 gas/NEWS                                    |   4 +
 gas/config/obj-elf.c                        |  59 ++++++++++
 gas/doc/as.texi                             |  20 ++++
 gas/testsuite/gas/elf/elf.exp               |   5 +
 gas/testsuite/gas/elf/retain1.d             |  24 +++++
 gas/testsuite/gas/elf/retain1.s             | 114 ++++++++++++++++++++
 gas/testsuite/gas/elf/retain2.d             |   3 +
 gas/testsuite/gas/elf/retain2.l             |   3 +
 gas/testsuite/gas/elf/retain2.s             |   7 ++
 gas/testsuite/gas/elf/retain3.d             |  24 +++++
 gas/testsuite/gas/elf/retain3.s             | 104 ++++++++++++++++++
 gas/testsuite/gas/elf/section10.d           |   4 +-
 include/elf/common.h                        |   1 +
 ld/NEWS                                     |   4 +
 ld/ld.texi                                  |   8 ++
 ld/testsuite/ld-elf/elf.exp                 |  38 ++++++-
 ld/testsuite/ld-elf/retain1.msg             |   9 ++
 ld/testsuite/ld-elf/retain1.s               | 114 ++++++++++++++++++++
 ld/testsuite/ld-elf/retain2.d               |   7 ++
 ld/testsuite/ld-elf/retain2.ld              |   7 ++
 ld/testsuite/ld-elf/retain2.map             |  32 ++++++
 ld/testsuite/ld-elf/retain3.msg             |   9 ++
 ld/testsuite/ld-elf/retain3.s               | 104 ++++++++++++++++++
 ld/testsuite/ld-elf/retain4.s               |  19 ++++
 ld/testsuite/ld-elf/retain5.s               |  13 +++
 ld/testsuite/ld-elf/retain6lib.s            |   6 ++
 ld/testsuite/ld-elf/retain6main.s           |   5 +
 ld/testsuite/ld-elf/retain7.msg             |   1 +
 ld/testsuite/ld-elf/retain7lib.s            |  17 +++
 ld/testsuite/ld-elf/retain7main.s           |  13 +++
 36 files changed, 921 insertions(+), 5 deletions(-)
 create mode 100644 binutils/testsuite/binutils-all/retain1.d
 create mode 100644 binutils/testsuite/binutils-all/retain1.s
 create mode 100644 gas/testsuite/gas/elf/retain1.d
 create mode 100644 gas/testsuite/gas/elf/retain1.s
 create mode 100644 gas/testsuite/gas/elf/retain2.d
 create mode 100644 gas/testsuite/gas/elf/retain2.l
 create mode 100644 gas/testsuite/gas/elf/retain2.s
 create mode 100644 gas/testsuite/gas/elf/retain3.d
 create mode 100644 gas/testsuite/gas/elf/retain3.s
 create mode 100644 ld/testsuite/ld-elf/retain1.msg
 create mode 100644 ld/testsuite/ld-elf/retain1.s
 create mode 100644 ld/testsuite/ld-elf/retain2.d
 create mode 100644 ld/testsuite/ld-elf/retain2.ld
 create mode 100644 ld/testsuite/ld-elf/retain2.map
 create mode 100644 ld/testsuite/ld-elf/retain3.msg
 create mode 100644 ld/testsuite/ld-elf/retain3.s
 create mode 100644 ld/testsuite/ld-elf/retain4.s
 create mode 100644 ld/testsuite/ld-elf/retain5.s
 create mode 100644 ld/testsuite/ld-elf/retain6lib.s
 create mode 100644 ld/testsuite/ld-elf/retain6main.s
 create mode 100644 ld/testsuite/ld-elf/retain7.msg
 create mode 100644 ld/testsuite/ld-elf/retain7lib.s
 create mode 100644 ld/testsuite/ld-elf/retain7main.s

diff --git a/bfd/elflink.c b/bfd/elflink.c
index 0e339f3c1e..6d1a1c5105 100644
--- a/bfd/elflink.c
+++ b/bfd/elflink.c
@@ -13977,7 +13977,8 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
 			|| (elf_section_data (o)->this_hdr.sh_type
 			    == SHT_FINI_ARRAY)))
 		|| (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
-		    && elf_next_in_group (o) == NULL )))
+		    && elf_next_in_group (o) == NULL)
+		|| (elf_section_flags (o) & SHF_GNU_RETAIN)))
 	  {
 	    if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
 	      return FALSE;
diff --git a/binutils/NEWS b/binutils/NEWS
index c0dc73d7d8..6c7d3f3953 100644
--- a/binutils/NEWS
+++ b/binutils/NEWS
@@ -4,6 +4,10 @@
   symbol names.  In addition the --demangle=<style>, --no-demangle,
   --recurse-limit and --no-recurse-limit options are also now availale.
 
+* Add support for the SHF_GNU_RETAIN ELF section flag.
+  This flag specifies that the section should not be garbage collected by the
+  linker if it is unused.
+
 Changes in 2.35:
 
 * Changed readelf's display of symbol names when wide mode is not enabled.
diff --git a/binutils/readelf.c b/binutils/readelf.c
index cb4208f7b9..00502f7058 100644
--- a/binutils/readelf.c
+++ b/binutils/readelf.c
@@ -5977,6 +5977,8 @@ get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
       /* VLE specific.  */
       /* 25 */ { STRING_COMMA_LEN ("VLE") },
+      /* GNU specific.  */
+      /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
     };
 
   if (do_section_details)
@@ -6010,6 +6012,7 @@ get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
 	    case SHF_EXCLUDE:		sindex = 18; break;
 	    case SHF_COMPRESSED:	sindex = 20; break;
 	    case SHF_GNU_MBIND:		sindex = 24; break;
+	    case SHF_GNU_RETAIN:	sindex = 26; break;
 
 	    default:
 	      sindex = -1;
@@ -6108,6 +6111,7 @@ get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
 	    case SHF_EXCLUDE:		*p = 'E'; break;
 	    case SHF_COMPRESSED:	*p = 'C'; break;
 	    case SHF_GNU_MBIND:		*p = 'D'; break;
+	    case SHF_GNU_RETAIN:	*p = 'R'; break;
 
 	    default:
 	      if ((filedata->file_header.e_machine == EM_X86_64
diff --git a/binutils/testsuite/binutils-all/readelf.exp b/binutils/testsuite/binutils-all/readelf.exp
index 1fb36ae5c4..6dea09e305 100644
--- a/binutils/testsuite/binutils-all/readelf.exp
+++ b/binutils/testsuite/binutils-all/readelf.exp
@@ -364,8 +364,12 @@ readelf_wi_test
 readelf_compressed_wa_test
 
 readelf_dump_test
-run_dump_test "pr25543"
 
+# These dump tests require an assembler.
+if {[which $AS] != 0} then {
+    run_dump_test "pr25543"
+    run_dump_test "retain1"
+}
 
 # PR 13482 - Check for off-by-one errors when dumping .note sections.
 if {![binutils_assemble $srcdir/$subdir/version.s tmpdir/version.o]} then {
diff --git a/binutils/testsuite/binutils-all/retain1.d b/binutils/testsuite/binutils-all/retain1.d
new file mode 100644
index 0000000000..35d7373cc1
--- /dev/null
+++ b/binutils/testsuite/binutils-all/retain1.d
@@ -0,0 +1,17 @@
+#source: retain1.s
+#readelf: -S --wide
+#name: readelf SHF_GNU_RETAIN
+
+#...
+  \[[ 0-9]+\] .bss.retain0.*WAR.*
+  \[[ 0-9]+\] .bss.retain1.*WAR.*
+  \[[ 0-9]+\] .data.retain2.*WAR.*
+  \[[ 0-9]+\] .bss.sretain0.*WAR.*
+  \[[ 0-9]+\] .bss.sretain1.*WAR.*
+  \[[ 0-9]+\] .data.sretain2.*WAR.*
+  \[[ 0-9]+\] .text.fnretain1.*AXR.*
+#...
+  \[[ 0-9]+\] .bss.lsretain0.*WAR.*
+  \[[ 0-9]+\] .bss.lsretain1.*WAR.*
+  \[[ 0-9]+\] .data.lsretain2.*WAR.*
+#pass
diff --git a/binutils/testsuite/binutils-all/retain1.s b/binutils/testsuite/binutils-all/retain1.s
new file mode 100644
index 0000000000..e799ff72ec
--- /dev/null
+++ b/binutils/testsuite/binutils-all/retain1.s
@@ -0,0 +1,114 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"aw"
+	.type	retain0, STT_OBJECT
+	.retain	.bss.retain0
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"aw"
+	.type	retain1, STT_OBJECT
+	.retain	.bss.retain1
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"aw"
+	.type	retain2, STT_OBJECT
+	.retain	.data.retain2
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"aw"
+	.type	sretain0, STT_OBJECT
+	.retain	.bss.sretain0
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"aw"
+	.type	sretain1, STT_OBJECT
+	.retain	.bss.sretain1
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aw"
+	.type	sretain2, STT_OBJECT
+	.retain	.data.sretain2
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"ax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+	.retain	.text.fnretain1
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"aw"
+	.type	lsretain0.2, STT_OBJECT
+	.retain	.bss.lsretain0
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aw"
+	.type	lsretain1.1, STT_OBJECT
+	.retain	.bss.lsretain1
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aw"
+	.type	lsretain2.0, STT_OBJECT
+	.retain	.data.lsretain2
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/gas/NEWS b/gas/NEWS
index 66afd0357b..0d63fad7b3 100644
--- a/gas/NEWS
+++ b/gas/NEWS
@@ -9,6 +9,10 @@
 
 * Configure with --enable-x86-used-note by default for Linux/x86.
 
+* Add support for the .retain directive, which applies the ELF SHF_GNU_RETAIN
+  flag to the specified section.  This flag specifies the section should not be
+  garbage collected by the linker if it is unused.
+
 Changes in 2.35:
 
 * X86 NaCl target support is removed.
diff --git a/gas/config/obj-elf.c b/gas/config/obj-elf.c
index 9e39707801..1469a46039 100644
--- a/gas/config/obj-elf.c
+++ b/gas/config/obj-elf.c
@@ -78,6 +78,7 @@ static void obj_elf_gnu_attribute (int);
 static void obj_elf_tls_common (int);
 static void obj_elf_lcomm (int);
 static void obj_elf_struct (int);
+static void obj_elf_retain (int);
 
 static const pseudo_typeS elf_pseudo_table[] =
 {
@@ -119,6 +120,9 @@ static const pseudo_typeS elf_pseudo_table[] =
   /* A GNU extension for object attributes.  */
   {"gnu_attribute", obj_elf_gnu_attribute, 0},
 
+  /* A GNU extension for preventing linker garbage collection of sections.  */
+  {"retain", obj_elf_retain, 0},
+
   /* These are used for dwarf.  */
   {"2byte", cons, 2},
   {"4byte", cons, 4},
@@ -857,6 +861,9 @@ obj_elf_parse_section_letters (char *str, size_t len,
 	case 'd':
 	  *gnu_attr |= SHF_GNU_MBIND;
 	  break;
+	case 'R':
+	  *gnu_attr |= SHF_GNU_RETAIN;
+	  break;
 	case '?':
 	  *is_clone = TRUE;
 	  break;
@@ -1986,6 +1993,58 @@ obj_elf_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
   obj_elf_vendor_attribute (OBJ_ATTR_GNU);
 }
 
+/* Parse a ".retain [name]" directive.
+   The SHF_GNU_RETAIN flag should be applied to the section named "name".
+   If "name" is omitted, apply the flag to the current section being
+   assembled.  */
+static void
+obj_elf_retain (int ignored ATTRIBUTE_UNUSED)
+{
+  const char *name;
+  symbolS *secsym;
+  asection *bfdsec;
+
+  SKIP_WHITESPACE ();
+  if (*input_line_pointer == '\n')
+    {
+      /* Handle the case when "name" isn't specified.  */
+      name = now_seg->name;
+      if (name == NULL)
+	{
+	  as_bad (_("\".retain\" directive not within a section"));
+	  ignore_rest_of_line ();
+	  return;
+	}
+    }
+  else
+    {
+      /* The "name" argument has been given, validate it.  */
+      name = obj_elf_section_name ();
+      secsym = symbol_find (name);
+      if (secsym == NULL)
+	{
+	  as_bad (_("section '%s' has not been declared"), name);
+	  ignore_rest_of_line ();
+	  return;
+	}
+      else if (secsym != NULL
+	       && !symbol_section_p (secsym))
+	{
+	  as_bad (_("'%s' is not a section name, expected "
+		    "\".retain [name]\""), name);
+	  ignore_rest_of_line ();
+	  return;
+	}
+    }
+  demand_empty_rest_of_line ();
+
+  bfdsec = bfd_get_section_by_name (stdoutput, name);
+  if (bfdsec != NULL)
+    elf_section_flags (bfdsec) |= SHF_GNU_RETAIN;
+  else
+    as_bad (_("Couldn't find BFD section for %s\n"), name);
+}
+
 void
 elf_obj_read_begin_hook (void)
 {
diff --git a/gas/doc/as.texi b/gas/doc/as.texi
index 112eaf810c..68afaa6aae 100644
--- a/gas/doc/as.texi
+++ b/gas/doc/as.texi
@@ -4468,6 +4468,7 @@ Some machine configurations provide additional directives.
 * Quad::                        @code{.quad @var{bignums}}
 * Reloc::			@code{.reloc @var{offset}, @var{reloc_name}[, @var{expression}]}
 * Rept::			@code{.rept @var{count}}
+* Retain::			@code{.retain [@var{name}]}
 * Sbttl::                       @code{.sbttl "@var{subheading}"}
 @ifset COFF
 * Scl::                         @code{.scl @var{class}}
@@ -6468,6 +6469,22 @@ is equivalent to assembling
 A count of zero is allowed, but nothing is generated.  Negative counts are not
 allowed and if encountered will be treated as if they were zero.
 
+@ifset ELF
+@node Retain
+@section @code{.retain [@var{name}]}
+
+@cindex @code{retain} directive
+@cindex SHF_GNU_RETAIN
+
+Apply the @code{SHF_GNU_RETAIN} flag to the section named @var{name}.
+If @var{name} is omitted, apply the flag to the current section being
+assembled.
+
+The @code{SHF_GNU_RETAIN} flag specifies that the section should not be
+garbage collected by the linker if it is unused.
+
+@end ifset
+
 @node Sbttl
 @section @code{.sbttl "@var{subheading}"}
 
@@ -6546,6 +6563,9 @@ ignored.  (For compatibility with the ELF version)
 section is not readable (meaningful for PE targets)
 @item 0-9
 single-digit power-of-two section alignment (GNU extension)
+@item R
+retained section (apply SHF_GNU_RETAIN to prevent linker garbage
+collection, GNU ELF extension)
 @end table
 
 If no flags are specified, the default flags depend upon the section name.  If
diff --git a/gas/testsuite/gas/elf/elf.exp b/gas/testsuite/gas/elf/elf.exp
index 8520421ba3..3a4879e348 100644
--- a/gas/testsuite/gas/elf/elf.exp
+++ b/gas/testsuite/gas/elf/elf.exp
@@ -307,6 +307,11 @@ if { [is_elf_format] } then {
 
     run_dump_test "strtab"
 
+    # Tests for the .retain directive/SHF_GNU_RETAIN.
+    run_dump_test "retain1"
+    run_dump_test "retain2"
+    run_dump_test "retain3"
+
     run_dump_test "bignums"
     run_dump_test "section-symbol-redef"
     
diff --git a/gas/testsuite/gas/elf/retain1.d b/gas/testsuite/gas/elf/retain1.d
new file mode 100644
index 0000000000..439a60ca21
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain1.d
@@ -0,0 +1,24 @@
+#readelf: -S --wide
+#name: SHF_GNU_RETAIN 1
+
+#...
+  \[..\] .bss.discard0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.discard1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .data.discard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.sdiscard0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.sdiscard1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .data.sdiscard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .text.fndiscard0[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  AX.*
+  \[..\] .bss.retain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.retain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.retain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.sretain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.sretain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.sretain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .text.fnretain1[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 AXR.*
+  \[..\] .text.fndiscard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  AX.*
+#...
+  \[..\] .bss.lsretain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.lsretain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.lsretain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+#pass
diff --git a/gas/testsuite/gas/elf/retain1.s b/gas/testsuite/gas/elf/retain1.s
new file mode 100644
index 0000000000..e799ff72ec
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain1.s
@@ -0,0 +1,114 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"aw"
+	.type	retain0, STT_OBJECT
+	.retain	.bss.retain0
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"aw"
+	.type	retain1, STT_OBJECT
+	.retain	.bss.retain1
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"aw"
+	.type	retain2, STT_OBJECT
+	.retain	.data.retain2
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"aw"
+	.type	sretain0, STT_OBJECT
+	.retain	.bss.sretain0
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"aw"
+	.type	sretain1, STT_OBJECT
+	.retain	.bss.sretain1
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aw"
+	.type	sretain2, STT_OBJECT
+	.retain	.data.sretain2
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"ax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+	.retain	.text.fnretain1
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"aw"
+	.type	lsretain0.2, STT_OBJECT
+	.retain	.bss.lsretain0
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aw"
+	.type	lsretain1.1, STT_OBJECT
+	.retain	.bss.lsretain1
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aw"
+	.type	lsretain2.0, STT_OBJECT
+	.retain	.data.lsretain2
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/gas/testsuite/gas/elf/retain2.d b/gas/testsuite/gas/elf/retain2.d
new file mode 100644
index 0000000000..ca58b250b6
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain2.d
@@ -0,0 +1,3 @@
+#name: SHF_GNU_RETAIN 2
+#error_output: retain2.l
+#skip: hppa-*-*
diff --git a/gas/testsuite/gas/elf/retain2.l b/gas/testsuite/gas/elf/retain2.l
new file mode 100644
index 0000000000..5a44012567
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain2.l
@@ -0,0 +1,3 @@
+[^:]*: Assembler messages:
+[^:]*:1: Error: section '.data.foo' has not been declared
+[^:]*:7: Error: 'myvar' is not a section name, expected ".retain \[name\]"
diff --git a/gas/testsuite/gas/elf/retain2.s b/gas/testsuite/gas/elf/retain2.s
new file mode 100644
index 0000000000..75eb26d7f7
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain2.s
@@ -0,0 +1,7 @@
+.retain ".data.foo"
+.section .data,"aw"
+.global myvar
+.type myvar, STT_OBJECT
+myvar:
+	.byte 2
+.retain "myvar"
diff --git a/gas/testsuite/gas/elf/retain3.d b/gas/testsuite/gas/elf/retain3.d
new file mode 100644
index 0000000000..2d5ca68086
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain3.d
@@ -0,0 +1,24 @@
+#readelf: -S --wide
+#name: SHF_GNU_RETAIN 3 (use flags set on .section directive)
+
+#...
+  \[..\] .bss.discard0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.discard1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .data.discard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.sdiscard0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.sdiscard1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .data.sdiscard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .text.fndiscard0[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  AX.*
+  \[..\] .bss.retain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.retain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.retain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.sretain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.sretain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.sretain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .text.fnretain1[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 AXR.*
+  \[..\] .text.fndiscard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  AX.*
+#...
+  \[..\] .bss.lsretain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.lsretain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.lsretain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+#pass
diff --git a/gas/testsuite/gas/elf/retain3.s b/gas/testsuite/gas/elf/retain3.s
new file mode 100644
index 0000000000..065399ec6f
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain3.s
@@ -0,0 +1,104 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"awR"
+	.type	retain0, STT_OBJECT
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"awR"
+	.type	retain1, STT_OBJECT
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"awR"
+	.type	retain2, STT_OBJECT
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"awR"
+	.type	sretain0, STT_OBJECT
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"awR"
+	.type	sretain1, STT_OBJECT
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aRw"
+	.type	sretain2, STT_OBJECT
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"Rax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"awR"
+	.type	lsretain0.2, STT_OBJECT
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aRw"
+	.type	lsretain1.1, STT_OBJECT
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aRw"
+	.type	lsretain2.0, STT_OBJECT
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/gas/testsuite/gas/elf/section10.d b/gas/testsuite/gas/elf/section10.d
index 554a791f1d..ef91d7d086 100644
--- a/gas/testsuite/gas/elf/section10.d
+++ b/gas/testsuite/gas/elf/section10.d
@@ -18,7 +18,7 @@
 #...
 [ 	]*\[.*\][ 	]+sec3
 [ 	]*PROGBITS.*
-[ 	]*\[.*fefff030\]: MERGE, STRINGS,.* EXCLUDE, OS \(.*ef00000\), PROC \(.*[3467]0000000\), UNKNOWN \(0+0ff000\)
+[ 	]*\[.*fefff030\]: MERGE, STRINGS,.* EXCLUDE, OS \(.*ed00000\), PROC \(.*[3467]0000000\), UNKNOWN \(0+0ff000\)
 #...
 [ 	]*\[.*\][ 	]+sec4
 [ 	]*LOOS\+0x11[ 	].*
@@ -26,7 +26,7 @@
 #...
 [ 	]*\[.*\][ 	]+sec5
 [ 	]*LOUSER\+0x9[ 	].*
-[ 	]*\[.*feff0000\]:.* EXCLUDE, OS \(.*ef00000\), PROC \(.*[3467]0000000\), UNKNOWN \(.*f0000\)
+[ 	]*\[.*feff0000\]:.* EXCLUDE, OS \(.*ed00000\), PROC \(.*[3467]0000000\), UNKNOWN \(.*f0000\)
 [ 	]*\[.*\][ 	]+.data.foo
 [ 	]*LOUSER\+0x7f000000[ 	].*
 [ 	]*\[0+003\]: WRITE, ALLOC
diff --git a/include/elf/common.h b/include/elf/common.h
index 805058146a..364c58a7de 100644
--- a/include/elf/common.h
+++ b/include/elf/common.h
@@ -554,6 +554,7 @@
 /* #define SHF_MASKOS	0x0F000000    *//* OS-specific semantics */
 #define SHF_MASKOS	0x0FF00000	/* New value, Oct 4, 1999 Draft */
 #define SHF_GNU_BUILD_NOTE    (1 << 20)	/* Section contains GNU BUILD ATTRIBUTE notes.  */
+#define SHF_GNU_RETAIN	      (1 << 21)	/* Section should not be garbage collected by the linker.  */
 #define SHF_MASKPROC	0xF0000000	/* Processor-specific semantics */
 
 /* This used to be implemented as a processor specific section flag.
diff --git a/ld/NEWS b/ld/NEWS
index 695348141b..1c3cc9d20a 100644
--- a/ld/NEWS
+++ b/ld/NEWS
@@ -13,6 +13,10 @@
   unless you are working on a project that has its own analogue
   of symbol tables that are not reflected in the ELF symtabs.
 
+* Add support for the SHF_GNU_RETAIN ELF section flag.
+  This flag specifies that the section should not be garbage collected by the
+  linker if it is unused.
+
 Changes in 2.35:
 
 * X86 NaCl target support is removed.
diff --git a/ld/ld.texi b/ld/ld.texi
index 7d961c3bb8..5daffbeb5f 100644
--- a/ld/ld.texi
+++ b/ld/ld.texi
@@ -1781,6 +1781,10 @@ specified either by one of the options @samp{--entry},
 @samp{--undefined}, or @samp{--gc-keep-exported} or by a @code{ENTRY}
 command in the linker script.
 
+As a GNU extension, ELF input sections marked with the
+@code{SHF_GNU_RETAIN} flag will not be garbage collected if they are
+unused.
+
 @kindex --print-gc-sections
 @kindex --no-print-gc-sections
 @cindex garbage collection
@@ -5226,6 +5230,10 @@ The special output section name @samp{/DISCARD/} may be used to discard
 input sections.  Any input sections which are assigned to an output
 section named @samp{/DISCARD/} are not included in the output file.
 
+This can be used to discard input sections marked with the ELF flag
+@code{SHF_GNU_RETAIN}, which would otherwise have been saved from linker
+garbage collection when they are unused.
+
 Note, sections that match the @samp{/DISCARD/} output section will be
 discarded even if they are in an ELF section group which has other
 members which are not being discarded.  This is deliberate.
diff --git a/ld/testsuite/ld-elf/elf.exp b/ld/testsuite/ld-elf/elf.exp
index c0d67d80d2..bf39e0a586 100644
--- a/ld/testsuite/ld-elf/elf.exp
+++ b/ld/testsuite/ld-elf/elf.exp
@@ -188,6 +188,8 @@ if { [istarget *-*-*linux*]
 	]
 }
 
+# mmix is supposed to support --gc-sections, but the option has no effect,
+# so these tests are XFAIL'd for the target.
 if [check_gc_sections_available] {
     run_ld_link_tests [list \
 	[list "__patchable_function_entries section 2" \
@@ -225,7 +227,41 @@ if [check_gc_sections_available] {
 	    {pr25490-6.s} \
 	    [list [list "readelf" {-SW} $pr25490_6_exp]] \
 	    "pr25490-6.exe"] \
-	]
+	[list "SHF_GNU_RETAIN 1" \
+	    "--gc-sections -e _start --print-gc-sections" "" "" \
+	    {retain1.s} \
+	    {{ ld retain1.msg }} \
+	    "retain1.exe"] \
+	[list "SHF_GNU_RETAIN 3 (use flags set on .section directive)" \
+	    "--gc-sections -e _start --print-gc-sections" "" "" \
+	    {retain3.s} \
+	    {{ ld retain3.msg }} \
+	    "retain3.exe"] \
+	[list "SHF_GNU_RETAIN 4 (keep sections referenced by retained sections)" \
+	    "--gc-sections -e _start --print-gc-sections" "" "" \
+	    {retain4.s} {} \
+	    "retain4.exe"] \
+	[list "SHF_GNU_RETAIN 5 (keep orphaned sections when not discarding)" \
+	    "--gc-sections -e _start --print-gc-sections --orphan-handling=place" "" "" \
+	    {retain5.s} {} \
+	    "retain5.exe"] \
+	[list "Build libretain6.a" \
+	    "" "" "" \
+	    {retain6lib.s} {} "libretain6.a"] \
+	[list "SHF_GNU_RETAIN 6 (don't pull SHF_GNU_RETAIN section out of lib)" \
+	    "--gc-sections -e _start --print-gc-sections" "-Ltmpdir -lretain6" "" \
+	    {retain6main.s} {} \
+	    "retain6.exe"] \
+	[list "Build libretain7.a" \
+	    "" "" "" \
+	    {retain7lib.s} {} "libretain7.a"] \
+	[list "SHF_GNU_RETAIN 7 (pull section out of lib required by SHF_GNU_RETAIN section)" \
+	    "--gc-sections -e _start --print-gc-sections" "-Ltmpdir -lretain7" "" \
+	    {retain7main.s} \
+	    {{ ld retain7.msg }} \
+	    "retain7.exe"] \
+	] \
+    "mmix-*-*"
 }
 
 set LDFLAGS $old_ldflags
diff --git a/ld/testsuite/ld-elf/retain1.msg b/ld/testsuite/ld-elf/retain1.msg
new file mode 100644
index 0000000000..9a265c980f
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain1.msg
@@ -0,0 +1,9 @@
+.*: removing unused section '.bss.discard0' in file.*
+.*: removing unused section '.bss.discard1' in file.*
+.*: removing unused section '.data.discard2' in file.*
+.*: removing unused section '.bss.sdiscard0' in file.*
+.*: removing unused section '.bss.sdiscard1' in file.*
+.*: removing unused section '.data.sdiscard2' in file.*
+.*: removing unused section '.text.fndiscard0' in file.*
+.*: removing unused section '.text.fndiscard2' in file.*
+#pass
diff --git a/ld/testsuite/ld-elf/retain1.s b/ld/testsuite/ld-elf/retain1.s
new file mode 100644
index 0000000000..e799ff72ec
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain1.s
@@ -0,0 +1,114 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"aw"
+	.type	retain0, STT_OBJECT
+	.retain	.bss.retain0
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"aw"
+	.type	retain1, STT_OBJECT
+	.retain	.bss.retain1
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"aw"
+	.type	retain2, STT_OBJECT
+	.retain	.data.retain2
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"aw"
+	.type	sretain0, STT_OBJECT
+	.retain	.bss.sretain0
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"aw"
+	.type	sretain1, STT_OBJECT
+	.retain	.bss.sretain1
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aw"
+	.type	sretain2, STT_OBJECT
+	.retain	.data.sretain2
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"ax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+	.retain	.text.fnretain1
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"aw"
+	.type	lsretain0.2, STT_OBJECT
+	.retain	.bss.lsretain0
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aw"
+	.type	lsretain1.1, STT_OBJECT
+	.retain	.bss.lsretain1
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aw"
+	.type	lsretain2.0, STT_OBJECT
+	.retain	.data.lsretain2
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain2.d b/ld/testsuite/ld-elf/retain2.d
new file mode 100644
index 0000000000..941b002948
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain2.d
@@ -0,0 +1,7 @@
+# Test that sections marked with SHF_GNU_RETAIN can be removed by placing them
+# in /DISCARD/.
+# source: retain1.s
+# ld: -e _start -Map=retain2.map --gc-sections --script=retain2.ld
+# map: retain2.map
+# skip: mep-*-* dlx-*-* d30v-*-* pj-*-* pru-*-* xgate-*-* s12z-*-*
+# xfail: mmix-*-*
diff --git a/ld/testsuite/ld-elf/retain2.ld b/ld/testsuite/ld-elf/retain2.ld
new file mode 100644
index 0000000000..8ef982753c
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain2.ld
@@ -0,0 +1,7 @@
+SECTIONS
+{
+  /DISCARD/ :
+  {
+    *(.text.fnretain1)
+  }
+}
diff --git a/ld/testsuite/ld-elf/retain2.map b/ld/testsuite/ld-elf/retain2.map
new file mode 100644
index 0000000000..4028aa1f58
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain2.map
@@ -0,0 +1,32 @@
+# Test that .text.fnretain1, which has the SHF_GNU_RETAIN flag, can still be
+# explicitly discarded from the output file.
+
+#...
+Discarded input sections
+
+ .text.*
+#...
+ .data.*
+#...
+ .bss.*
+#...
+ .bss.discard0.*
+#...
+ .bss.discard1.*
+#...
+ .data.discard2.*
+#...
+ .bss.sdiscard0.*
+#...
+ .bss.sdiscard1.*
+#...
+ .data.sdiscard2.*
+#...
+ .text.fndiscard0.*
+#...
+ .text.fnretain1.*
+#...
+ .text.fndiscard2.*
+#...
+Memory Configuration
+#pass
diff --git a/ld/testsuite/ld-elf/retain3.msg b/ld/testsuite/ld-elf/retain3.msg
new file mode 100644
index 0000000000..9a265c980f
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain3.msg
@@ -0,0 +1,9 @@
+.*: removing unused section '.bss.discard0' in file.*
+.*: removing unused section '.bss.discard1' in file.*
+.*: removing unused section '.data.discard2' in file.*
+.*: removing unused section '.bss.sdiscard0' in file.*
+.*: removing unused section '.bss.sdiscard1' in file.*
+.*: removing unused section '.data.sdiscard2' in file.*
+.*: removing unused section '.text.fndiscard0' in file.*
+.*: removing unused section '.text.fndiscard2' in file.*
+#pass
diff --git a/ld/testsuite/ld-elf/retain3.s b/ld/testsuite/ld-elf/retain3.s
new file mode 100644
index 0000000000..065399ec6f
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain3.s
@@ -0,0 +1,104 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"awR"
+	.type	retain0, STT_OBJECT
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"awR"
+	.type	retain1, STT_OBJECT
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"awR"
+	.type	retain2, STT_OBJECT
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"awR"
+	.type	sretain0, STT_OBJECT
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"awR"
+	.type	sretain1, STT_OBJECT
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aRw"
+	.type	sretain2, STT_OBJECT
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"Rax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"awR"
+	.type	lsretain0.2, STT_OBJECT
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aRw"
+	.type	lsretain1.1, STT_OBJECT
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aRw"
+	.type	lsretain2.0, STT_OBJECT
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain4.s b/ld/testsuite/ld-elf/retain4.s
new file mode 100644
index 0000000000..080a5dfc2e
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain4.s
@@ -0,0 +1,19 @@
+/* The retention of bar should also prevent foo from being gc'ed, since bar
+   references foo.  */
+	.section	.text.foo,"ax"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.word 0
+
+	.section	.text.bar,"axR"
+	.global	bar
+	.type	bar, STT_FUNC
+bar:
+	.long foo
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain5.s b/ld/testsuite/ld-elf/retain5.s
new file mode 100644
index 0000000000..5ffadad694
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain5.s
@@ -0,0 +1,13 @@
+/* A section which doesn't match any linker script input section rules but
+   has SHF_GNU_RETAIN applied should not be garbage collected.  */
+	.section	.orphaned_section,"axR"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.word 0
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain6lib.s b/ld/testsuite/ld-elf/retain6lib.s
new file mode 100644
index 0000000000..4de7adea3d
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain6lib.s
@@ -0,0 +1,6 @@
+/* The link will fail if foo is included because undefined_sym is not defined.  */
+	.section	.text.foo,"axR"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.long undefined_sym
diff --git a/ld/testsuite/ld-elf/retain6main.s b/ld/testsuite/ld-elf/retain6main.s
new file mode 100644
index 0000000000..7c722481e8
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain6main.s
@@ -0,0 +1,5 @@
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain7.msg b/ld/testsuite/ld-elf/retain7.msg
new file mode 100644
index 0000000000..c21e3b9d75
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain7.msg
@@ -0,0 +1 @@
+.*: removing unused section '.text.discard_from_lib' in file.*
diff --git a/ld/testsuite/ld-elf/retain7lib.s b/ld/testsuite/ld-elf/retain7lib.s
new file mode 100644
index 0000000000..2aebf32bd0
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain7lib.s
@@ -0,0 +1,17 @@
+	.section	.text.bar,"ax"
+	.global	bar
+	.type	bar, STT_FUNC
+bar:
+	.word 0
+
+	.section	.text.retain_from_lib,"axR"
+	.global	retain_from_lib
+	.type	retain_from_lib, STT_FUNC
+retain_from_lib:
+	.word 0
+
+	.section	.text.discard_from_lib,"ax"
+	.global	discard_from_lib
+	.type	discard_from_lib, STT_FUNC
+discard_from_lib:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain7main.s b/ld/testsuite/ld-elf/retain7main.s
new file mode 100644
index 0000000000..d8ce70e718
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain7main.s
@@ -0,0 +1,13 @@
+/* Undefined symbol reference in retained section .text.foo requires symbol
+   definition to be pulled out of library.  */
+	.section	.text.foo,"axR"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.long bar
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
-- 
2.28.0

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Hans-Peter Nilsson]

On Tue, 22 Sep 2020, Jozef Lawrynowicz wrote:
> The new tests are passing for all targets except mmix-elf.

There is no mmix-elf target: if it's buildable, that's a
mistake.  I'm not sure what kind of abomination results, if it's
a goldblum-fly or karloff-frankensteins. :)

The target mmix a.k.a. mmix-knuth-mmixware assembles to ELF, but
links to MMO by use of the generic linker machinery.  You *can*
link to ELF by means of the linker option "-m elf64mmix".

brgds, H-P

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[H.J. Lu]

On Tue, Sep 22, 2020 at 1:30 PM Jozef Lawrynowicz
<jozef.l@mittosystems.com> wrote:
>
> The attached patch adds support for the new SHF_GNU_RETAIN ELF section
> flag, which was discussed on the GNU gABI mailing list here:
> https://sourceware.org/pipermail/gnu-gabi/2020q3/000429.html
>
> The flag is GNU-specific so uses a bit in the SHF_MASKOS mask.
> Its precise definition is as follows:
>
> =======================================================================
> Section Attribute Flags
> +-------------------------------------+
> | Name           | Value              |
> +-------------------------------------+
> | SHF_GNU_RETAIN | 0x200000 (1 << 21) |
> +-------------------------------------+
>
> SHF_GNU_RETAIN
>   The link editor should not garbage collect the section if it is
>   unused.
>
> =======================================================================
>
> The overall intention for this new flag is to enable a new "retain"
> attribute to be applied to declarations of functions and data in the
> source code. This attribute can be used to ensure the definition
> associated with the declaration is present in the linked output file,
> even if linker garbage collection would normally remove the containing
> section because it is unused.
>
> The new ".retain" assembler directive can be used to apply
> SHF_GNU_RETAIN to a section. GCC will emit this directive when
> assembling definitions of functions and data that have had the "retain"
> attribute applied.
>
> Note that there is *not* a direct mapping of SHF_GNU_RETAIN to the BFD
> section flag SEC_KEEP. SEC_KEEP would prevent the user being able to
> explicitly remove an SHF_GNU_RETAIN section by placing it in /DISCARD/,
> which could be necessary in some situations.
>
> I successfully regtested the patch for the Binutils, GAS and LD
> testsuites for the following CPUs, applying the "-elf" suffix when
> configuring:
>   aarch64 alpha arc arm avr bfin bpf cr16 cris crx csky d10v d30v dlx
>   epiphany fr30 frv ft32 h8300 hppa i386 ia64 ia64-vms ip2k iq2000 lm32
>   m32c m32r m68hc11 m68hc12 m68k mcore mep metag microblaze mips mmix
>   moxie msp430 mt nds32 nfp nios2 or1k pj ppc pru riscv rl78 rx s12z
>   s390 score sh sparc spu tic6x tilegx tilepro v850 vax visium wasm32
>   x86-64 x86 xc16x xgate xstormy16 xtensa z80
>
> The new tests are passing for all targets except mmix-elf. This target
> has a lot of LD failures, particularly --gc-sections doesn't appear to
> have any effect. I don't know anything about the target, but I wonder if
> it should be added to the hard-coded list of targets that doesn't
> support --gc-sections.  I have therefore XFAIL'd the new LD tests for
> this target.
>
> I also regtested for i386-pe, to ensure there was no spill-over of the
> new functionality into any non-ELF areas.
>
> Ok to apply?
>
> Thanks,
> Jozef

+  /* A GNU extension for preventing linker garbage collection of sections.  */
+  {"retain", obj_elf_retain, 0},
+

Why is this needed?  Isn't

@@ -857,6 +861,9 @@ obj_elf_parse_section_letters (char *str, size_t len,
  case 'd':
   *gnu_attr |= SHF_GNU_MBIND;
   break;
+ case 'R':
+  *gnu_attr |= SHF_GNU_RETAIN;
+  break;
  case '?':
   *is_clone = TRUE;
   break;

enough?  The .section directive is used for all other SHF_XXX bits.   I don't
think we need a separate directive for SHF_GNU_RETAIN?


-- 
H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Fangrui Song]

On 2020-09-22, Jozef Lawrynowicz wrote:
>The attached patch adds support for the new SHF_GNU_RETAIN ELF section
>flag, which was discussed on the GNU gABI mailing list here:
>https://sourceware.org/pipermail/gnu-gabi/2020q3/000429.html
>
>The flag is GNU-specific so uses a bit in the SHF_MASKOS mask.
>Its precise definition is as follows:

We already have a way to create an artificial reference:

   .reloc ., R_X86_64_NONE, target_symbol

If we allow a relocation number for the second operand

   .reloc ., 0, target_symbol

this will be generic. You can insert the directives in a GC root (e.g.
_start or a symbol referenced by -u or maybe an .init_array)

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Tue, Sep 22, 2020 at 07:24:01PM -0400, Hans-Peter Nilsson wrote:
> On Tue, 22 Sep 2020, Jozef Lawrynowicz wrote:
> > The new tests are passing for all targets except mmix-elf.
> 
> There is no mmix-elf target: if it's buildable, that's a
> mistake.  I'm not sure what kind of abomination results, if it's
> a goldblum-fly or karloff-frankensteins. :)
> 
> The target mmix a.k.a. mmix-knuth-mmixware assembles to ELF, but
> links to MMO by use of the generic linker machinery.  You *can*
> link to ELF by means of the linker option "-m elf64mmix".
> 
> brgds, H-P
> 

Ah, thanks for the info. I formed that list of targets by just
extracting the CPU name from all the files in bfd/ with "elf" in the
name.

mmix-elf is buildable, and most tests pass, but it definitely appears
that a lot is broken!

  ==> mmix-elf/binutils.sum <==
  # of expected passes            122
  # of unexpected failures        38
  ==> mmix-elf/gas.sum <==
  # of expected passes            446
  # of unexpected failures        68
  ==> mmix-elf/ld.sum <==
  # of expected passes            430
  # of unexpected failures        158

I'll remove any mmix-elf-specific XFAIL-ing from the patch.

On Tue, Sep 22, 2020 at 04:58:23PM -0700, H.J. Lu via Binutils wrote:
> On Tue, Sep 22, 2020 at 1:30 PM Jozef Lawrynowicz
> <jozef.l@mittosystems.com> wrote:
> >
> +  /* A GNU extension for preventing linker garbage collection of sections.  */
> +  {"retain", obj_elf_retain, 0},
> +
> 
> Why is this needed?  Isn't
> 
> @@ -857,6 +861,9 @@ obj_elf_parse_section_letters (char *str, size_t len,
>   case 'd':
>    *gnu_attr |= SHF_GNU_MBIND;
>    break;
> + case 'R':
> +  *gnu_attr |= SHF_GNU_RETAIN;
> +  break;
>   case '?':
>    *is_clone = TRUE;
>    break;
> 
> enough?  The .section directive is used for all other SHF_XXX bits.   I don't
> think we need a separate directive for SHF_GNU_RETAIN?

GCC doesn't know if SHF_GNU_RETAIN is required when creating a section,
since the "retain" attribute is applied to function and data
declarations.

So rather than emitting the section directive again, which could be
confusing if there are two almost identical section declarations, the
".retain" directive describes the precise augmentation to make to the
already-declared section.

I think that:

>  .section .text,"ax"
>    ...
>  foo:
>    ...
>  .retain
>  retained_fn:
>    ...

is some nice syntactic sugar compared to:

>  .section .text,"ax"
>    ...
>  foo:
>    ...
>  .section .text,"axR"
>  retained_fn:
>    ...

It's also partly for convenience; we have other directives which are
synonyms or short-hand for each other.

There's a bug in my patch where a .section directive without the
"R" flag overrides an earlier .section directive for the same section
with the "R" flag and clobbers SHF_GNU_RETAIN, I need to fix that.

On Tue, Sep 22, 2020 at 06:09:30PM -0700, Fangrui Song wrote:
> On 2020-09-22, Jozef Lawrynowicz wrote:
> > The attached patch adds support for the new SHF_GNU_RETAIN ELF section
> > flag, which was discussed on the GNU gABI mailing list here:
> > https://sourceware.org/pipermail/gnu-gabi/2020q3/000429.html
> > 
> > The flag is GNU-specific so uses a bit in the SHF_MASKOS mask.
> > Its precise definition is as follows:
> 
> We already have a way to create an artificial reference:
> 
>   .reloc ., R_X86_64_NONE, target_symbol
> 
> If we allow a relocation number for the second operand
> 
>   .reloc ., 0, target_symbol
> 
> this will be generic. You can insert the directives in a GC root (e.g.
> _start or a symbol referenced by -u or maybe an .init_array)

I don't really understand how this would work in most cases when the
compiler or assembler aren't building the file which will contain the
eventual GC root. How are they to know what the GC root is anyway? What
if the assumed GC root changes after the files are built?

I also don't see any advantage of re-purposing .reloc for this use case,
over having a precisely defined new section flag. You would also have to
look at relocations defined in the GC root function (mixed with
relocations used for other purposes) to work out which sections are
being retained, instead of having retention being a property of the
section itself.

Thanks,
Jozef

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[H.J. Lu]

On Wed, Sep 23, 2020 at 2:58 AM Jozef Lawrynowicz
<jozef.l@mittosystems.com> wrote:
>
> On Tue, Sep 22, 2020 at 07:24:01PM -0400, Hans-Peter Nilsson wrote:
> > On Tue, 22 Sep 2020, Jozef Lawrynowicz wrote:
> > > The new tests are passing for all targets except mmix-elf.
> >
> > There is no mmix-elf target: if it's buildable, that's a
> > mistake.  I'm not sure what kind of abomination results, if it's
> > a goldblum-fly or karloff-frankensteins. :)
> >
> > The target mmix a.k.a. mmix-knuth-mmixware assembles to ELF, but
> > links to MMO by use of the generic linker machinery.  You *can*
> > link to ELF by means of the linker option "-m elf64mmix".
> >
> > brgds, H-P
> >
>
> Ah, thanks for the info. I formed that list of targets by just
> extracting the CPU name from all the files in bfd/ with "elf" in the
> name.
>
> mmix-elf is buildable, and most tests pass, but it definitely appears
> that a lot is broken!
>
>   ==> mmix-elf/binutils.sum <==
>   # of expected passes            122
>   # of unexpected failures        38
>   ==> mmix-elf/gas.sum <==
>   # of expected passes            446
>   # of unexpected failures        68
>   ==> mmix-elf/ld.sum <==
>   # of expected passes            430
>   # of unexpected failures        158
>
> I'll remove any mmix-elf-specific XFAIL-ing from the patch.
>
> On Tue, Sep 22, 2020 at 04:58:23PM -0700, H.J. Lu via Binutils wrote:
> > On Tue, Sep 22, 2020 at 1:30 PM Jozef Lawrynowicz
> > <jozef.l@mittosystems.com> wrote:
> > >
> > +  /* A GNU extension for preventing linker garbage collection of sections.  */
> > +  {"retain", obj_elf_retain, 0},
> > +
> >
> > Why is this needed?  Isn't
> >
> > @@ -857,6 +861,9 @@ obj_elf_parse_section_letters (char *str, size_t len,
> >   case 'd':
> >    *gnu_attr |= SHF_GNU_MBIND;
> >    break;
> > + case 'R':
> > +  *gnu_attr |= SHF_GNU_RETAIN;
> > +  break;
> >   case '?':
> >    *is_clone = TRUE;
> >    break;
> >
> > enough?  The .section directive is used for all other SHF_XXX bits.   I don't
> > think we need a separate directive for SHF_GNU_RETAIN?
>
> GCC doesn't know if SHF_GNU_RETAIN is required when creating a section,
> since the "retain" attribute is applied to function and data
> declarations.
>
> So rather than emitting the section directive again, which could be
> confusing if there are two almost identical section declarations, the
> ".retain" directive describes the precise augmentation to make to the
> already-declared section.
>
> I think that:
>
> >  .section .text,"ax"
> >    ...
> >  foo:
> >    ...
> >  .retain
> >  retained_fn:
> >    ...
>
> is some nice syntactic sugar compared to:
>
> >  .section .text,"ax"
> >    ...
> >  foo:
> >    ...
> >  .section .text,"axR"
> >  retained_fn:
> >    ...
>
> It's also partly for convenience; we have other directives which are
> synonyms or short-hand for each other.
>

You don't need to keep the whole section when only one symbol should
be kept.  Please drop the .retain directive.  GCC, as and ld should do the
right thing with

.section .text,"ax"
   ...
foo:
  ...
 .section .text,"axR"

 retained_fn:

where foo can be dropped and retained_fn will be kept.

H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Michael Matz]

Hello,

On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:

> > I think that:
> >
> > >  .section .text,"ax"
> > >    ...
> > >  foo:
> > >    ...
> > >  .retain
> > >  retained_fn:
> > >    ...
> >
> > is some nice syntactic sugar compared to:
> >
> > >  .section .text,"ax"
> > >    ...
> > >  foo:
> > >    ...
> > >  .section .text,"axR"
> > >  retained_fn:
> > >    ...
> >
> > It's also partly for convenience; we have other directives which are
> > synonyms or short-hand for each other.
> >
> 
> You don't need to keep the whole section when only one symbol should
> be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> right thing with
> 
> .section .text,"ax"
>    ...
> foo:
>   ...
>  .section .text,"axR"
> 
>  retained_fn:
> 
> where foo can be dropped and retained_fn will be kept.

This is not what we discussed at the ABI list, the flag is per section, so 
either the whole section is retained or not.  What you describe is 
something else that would work on a per symbol basis, which would have to 
be specified in a different way and might or might not be a good idea.  
But let's not conflate these two.

About the .retain syntactic sugar: I also think it's not necessary, the 
.section directive with R flag merging is good enough IMHO.


Ciao,
Michael.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> Hello,
> 
> On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> 
> > > I think that:
> > >
> > > >  .section .text,"ax"
> > > >    ...
> > > >  foo:
> > > >    ...
> > > >  .retain
> > > >  retained_fn:
> > > >    ...
> > >
> > > is some nice syntactic sugar compared to:
> > >
> > > >  .section .text,"ax"
> > > >    ...
> > > >  foo:
> > > >    ...
> > > >  .section .text,"axR"
> > > >  retained_fn:
> > > >    ...
> > >
> > > It's also partly for convenience; we have other directives which are
> > > synonyms or short-hand for each other.
> > >
> > 
> > You don't need to keep the whole section when only one symbol should
> > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > right thing with
> > 
> > .section .text,"ax"
> >    ...
> > foo:
> >   ...
> >  .section .text,"axR"
> > 
> >  retained_fn:
> > 
> > where foo can be dropped and retained_fn will be kept.
> 
> This is not what we discussed at the ABI list, the flag is per section, so 
> either the whole section is retained or not.  What you describe is 
> something else that would work on a per symbol basis, which would have to 
> be specified in a different way and might or might not be a good idea.  
> But let's not conflate these two.

Also, the linker cannot currently dissect a section and remove a
particular unused symbol anyway. Since garbage collection only operates
on the section level, marking the section itself as "retained" seems
most appropriate.

As an aside.. we would run into limitations in the ELF format if trying
to mark the symbol itself as "retained". You cannot define "retain" as a
new symbol type or binding, because there is not a one-to-one mapping of
"retain" to the existing symbol types and bindings i.e. a retained
symbol might be STT_OBJECT or STT_FUNC, or STB_LOCAL or STB_GLOBAL.
st_other could be another place to store the requirement to "retain" a
symbol, but all those available bits are used up (albeit some
unofficially).

I'm not saying there's no way it could be done, but these are the
hurdles I discovered when considering that path to implementing the
"retain" behavior.

> About the .retain syntactic sugar: I also think it's not necessary, the 
> .section directive with R flag merging is good enough IMHO.

I'm OK with removing the .retain directive, since there is some
consensus it is not necessary. Also, I thought it made life easier for
GCC to mark sections as retained by omitting the section name from the
directive, but I've discovered a way around that now.

Thanks,
Jozef

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[H.J. Lu]

On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
<jozef.l@mittosystems.com> wrote:
>
> On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > Hello,
> >
> > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> >
> > > > I think that:
> > > >
> > > > >  .section .text,"ax"
> > > > >    ...
> > > > >  foo:
> > > > >    ...
> > > > >  .retain
> > > > >  retained_fn:
> > > > >    ...
> > > >
> > > > is some nice syntactic sugar compared to:
> > > >
> > > > >  .section .text,"ax"
> > > > >    ...
> > > > >  foo:
> > > > >    ...
> > > > >  .section .text,"axR"
> > > > >  retained_fn:
> > > > >    ...
> > > >
> > > > It's also partly for convenience; we have other directives which are
> > > > synonyms or short-hand for each other.
> > > >
> > >
> > > You don't need to keep the whole section when only one symbol should
> > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > right thing with
> > >
> > > .section .text,"ax"
> > >    ...
> > > foo:
> > >   ...
> > >  .section .text,"axR"
> > >
> > >  retained_fn:
> > >
> > > where foo can be dropped and retained_fn will be kept.
> >
> > This is not what we discussed at the ABI list, the flag is per section, so
> > either the whole section is retained or not.  What you describe is
> > something else that would work on a per symbol basis, which would have to
> > be specified in a different way and might or might not be a good idea.
> > But let's not conflate these two.
>
> Also, the linker cannot currently dissect a section and remove a
> particular unused symbol anyway. Since garbage collection only operates
> on the section level, marking the section itself as "retained" seems
> most appropriate.

It can be done.  If you put your branch on

https://gitlab.com/x86-binutils/binutils-gdb

I can help you implement it.

> As an aside.. we would run into limitations in the ELF format if trying
> to mark the symbol itself as "retained". You cannot define "retain" as a
> new symbol type or binding, because there is not a one-to-one mapping of
> "retain" to the existing symbol types and bindings i.e. a retained
> symbol might be STT_OBJECT or STT_FUNC, or STB_LOCAL or STB_GLOBAL.
> st_other could be another place to store the requirement to "retain" a
> symbol, but all those available bits are used up (albeit some
> unofficially).
>
> I'm not saying there's no way it could be done, but these are the
> hurdles I discovered when considering that path to implementing the
> "retain" behavior.
>
> > About the .retain syntactic sugar: I also think it's not necessary, the
> > .section directive with R flag merging is good enough IMHO.
>
> I'm OK with removing the .retain directive, since there is some
> consensus it is not necessary. Also, I thought it made life easier for
> GCC to mark sections as retained by omitting the section name from the
> directive, but I've discovered a way around that now.
>
> Thanks,
> Jozef



-- 
H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> <jozef.l@mittosystems.com> wrote:
> >
> > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > Hello,
> > >
> > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > >
> > > > > I think that:
> > > > >
> > > > > >  .section .text,"ax"
> > > > > >    ...
> > > > > >  foo:
> > > > > >    ...
> > > > > >  .retain
> > > > > >  retained_fn:
> > > > > >    ...
> > > > >
> > > > > is some nice syntactic sugar compared to:
> > > > >
> > > > > >  .section .text,"ax"
> > > > > >    ...
> > > > > >  foo:
> > > > > >    ...
> > > > > >  .section .text,"axR"
> > > > > >  retained_fn:
> > > > > >    ...
> > > > >
> > > > > It's also partly for convenience; we have other directives which are
> > > > > synonyms or short-hand for each other.
> > > > >
> > > >
> > > > You don't need to keep the whole section when only one symbol should
> > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > right thing with
> > > >
> > > > .section .text,"ax"
> > > >    ...
> > > > foo:
> > > >   ...
> > > >  .section .text,"axR"
> > > >
> > > >  retained_fn:
> > > >
> > > > where foo can be dropped and retained_fn will be kept.
> > >
> > > This is not what we discussed at the ABI list, the flag is per section, so
> > > either the whole section is retained or not.  What you describe is
> > > something else that would work on a per symbol basis, which would have to
> > > be specified in a different way and might or might not be a good idea.
> > > But let's not conflate these two.
> >
> > Also, the linker cannot currently dissect a section and remove a
> > particular unused symbol anyway. Since garbage collection only operates
> > on the section level, marking the section itself as "retained" seems
> > most appropriate.
> 
> It can be done.  If you put your branch on
> 
> https://gitlab.com/x86-binutils/binutils-gdb
> 
> I can help you implement it.

It's not something I have time to look into at the moment, for now the
aim is just to prevent garbage collection of sections.

However, it would certainly be a useful enhancement for the linker, and
is something I would be interested in working on in the future, so I
appreciate the offer.

Thanks,
Jozef

> 
> > As an aside.. we would run into limitations in the ELF format if trying
> > to mark the symbol itself as "retained". You cannot define "retain" as a
> > new symbol type or binding, because there is not a one-to-one mapping of
> > "retain" to the existing symbol types and bindings i.e. a retained
> > symbol might be STT_OBJECT or STT_FUNC, or STB_LOCAL or STB_GLOBAL.
> > st_other could be another place to store the requirement to "retain" a
> > symbol, but all those available bits are used up (albeit some
> > unofficially).
> >
> > I'm not saying there's no way it could be done, but these are the
> > hurdles I discovered when considering that path to implementing the
> > "retain" behavior.
> >
> > > About the .retain syntactic sugar: I also think it's not necessary, the
> > > .section directive with R flag merging is good enough IMHO.
> >
> > I'm OK with removing the .retain directive, since there is some
> > consensus it is not necessary. Also, I thought it made life easier for
> > GCC to mark sections as retained by omitting the section name from the
> > directive, but I've discovered a way around that now.
> >
> > Thanks,
> > Jozef
> 
> 
> 
> -- 
> H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[H.J. Lu]

On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
<jozef.l@mittosystems.com> wrote:
>
> On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > <jozef.l@mittosystems.com> wrote:
> > >
> > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > Hello,
> > > >
> > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > >
> > > > > > I think that:
> > > > > >
> > > > > > >  .section .text,"ax"
> > > > > > >    ...
> > > > > > >  foo:
> > > > > > >    ...
> > > > > > >  .retain
> > > > > > >  retained_fn:
> > > > > > >    ...
> > > > > >
> > > > > > is some nice syntactic sugar compared to:
> > > > > >
> > > > > > >  .section .text,"ax"
> > > > > > >    ...
> > > > > > >  foo:
> > > > > > >    ...
> > > > > > >  .section .text,"axR"
> > > > > > >  retained_fn:
> > > > > > >    ...
> > > > > >
> > > > > > It's also partly for convenience; we have other directives which are
> > > > > > synonyms or short-hand for each other.
> > > > > >
> > > > >
> > > > > You don't need to keep the whole section when only one symbol should
> > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > right thing with
> > > > >
> > > > > .section .text,"ax"
> > > > >    ...
> > > > > foo:
> > > > >   ...
> > > > >  .section .text,"axR"
> > > > >
> > > > >  retained_fn:
> > > > >
> > > > > where foo can be dropped and retained_fn will be kept.
> > > >
> > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > either the whole section is retained or not.  What you describe is
> > > > something else that would work on a per symbol basis, which would have to
> > > > be specified in a different way and might or might not be a good idea.
> > > > But let's not conflate these two.
> > >
> > > Also, the linker cannot currently dissect a section and remove a
> > > particular unused symbol anyway. Since garbage collection only operates
> > > on the section level, marking the section itself as "retained" seems
> > > most appropriate.
> >
> > It can be done.  If you put your branch on
> >
> > https://gitlab.com/x86-binutils/binutils-gdb
> >
> > I can help you implement it.
>
> It's not something I have time to look into at the moment, for now the
> aim is just to prevent garbage collection of sections.

Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
to the framework.  Check how SHF_GNU_MBIND works.

> However, it would certainly be a useful enhancement for the linker, and
> is something I would be interested in working on in the future, so I
> appreciate the offer.
>

-- 
H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> <jozef.l@mittosystems.com> wrote:
> >
> > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > <jozef.l@mittosystems.com> wrote:
> > > >
> > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > Hello,
> > > > >
> > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > >
> > > > > > > I think that:
> > > > > > >
> > > > > > > >  .section .text,"ax"
> > > > > > > >    ...
> > > > > > > >  foo:
> > > > > > > >    ...
> > > > > > > >  .retain
> > > > > > > >  retained_fn:
> > > > > > > >    ...
> > > > > > >
> > > > > > > is some nice syntactic sugar compared to:
> > > > > > >
> > > > > > > >  .section .text,"ax"
> > > > > > > >    ...
> > > > > > > >  foo:
> > > > > > > >    ...
> > > > > > > >  .section .text,"axR"
> > > > > > > >  retained_fn:
> > > > > > > >    ...
> > > > > > >
> > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > synonyms or short-hand for each other.
> > > > > > >
> > > > > >
> > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > right thing with
> > > > > >
> > > > > > .section .text,"ax"
> > > > > >    ...
> > > > > > foo:
> > > > > >   ...
> > > > > >  .section .text,"axR"
> > > > > >
> > > > > >  retained_fn:
> > > > > >
> > > > > > where foo can be dropped and retained_fn will be kept.
> > > > >
> > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > either the whole section is retained or not.  What you describe is
> > > > > something else that would work on a per symbol basis, which would have to
> > > > > be specified in a different way and might or might not be a good idea.
> > > > > But let's not conflate these two.
> > > >
> > > > Also, the linker cannot currently dissect a section and remove a
> > > > particular unused symbol anyway. Since garbage collection only operates
> > > > on the section level, marking the section itself as "retained" seems
> > > > most appropriate.
> > >
> > > It can be done.  If you put your branch on
> > >
> > > https://gitlab.com/x86-binutils/binutils-gdb
> > >
> > > I can help you implement it.
> >
> > It's not something I have time to look into at the moment, for now the
> > aim is just to prevent garbage collection of sections.
> 
> Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> to the framework.  Check how SHF_GNU_MBIND works.

Sorry, I don't understand.

Are you saying that LD already supports the garbage collection of
individual unused symbol definitions from input sections? Whilst
retaining other symbol definitions which are required by the program?
I cannot find any reference to this.

How does that relate to SHF_GNU_MBIND? I looked at all the references
to "mbind" in Binutils and nothing seemed related garbage collection of
sections, since SHF_GNU_MBIND is just used to indicate a particular
section should be placed in a special memory area.

Thanks,
Jozef

> 
> > However, it would certainly be a useful enhancement for the linker, and
> > is something I would be interested in working on in the future, so I
> > appreciate the offer.
> >
> 
> -- 
> H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[H.J. Lu]

On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
<jozef.l@mittosystems.com> wrote:
>
> On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > <jozef.l@mittosystems.com> wrote:
> > >
> > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > <jozef.l@mittosystems.com> wrote:
> > > > >
> > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > Hello,
> > > > > >
> > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > >
> > > > > > > > I think that:
> > > > > > > >
> > > > > > > > >  .section .text,"ax"
> > > > > > > > >    ...
> > > > > > > > >  foo:
> > > > > > > > >    ...
> > > > > > > > >  .retain
> > > > > > > > >  retained_fn:
> > > > > > > > >    ...
> > > > > > > >
> > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > >
> > > > > > > > >  .section .text,"ax"
> > > > > > > > >    ...
> > > > > > > > >  foo:
> > > > > > > > >    ...
> > > > > > > > >  .section .text,"axR"
> > > > > > > > >  retained_fn:
> > > > > > > > >    ...
> > > > > > > >
> > > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > > synonyms or short-hand for each other.
> > > > > > > >
> > > > > > >
> > > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > > right thing with
> > > > > > >
> > > > > > > .section .text,"ax"
> > > > > > >    ...
> > > > > > > foo:
> > > > > > >   ...
> > > > > > >  .section .text,"axR"
> > > > > > >
> > > > > > >  retained_fn:
> > > > > > >
> > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > >
> > > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > > either the whole section is retained or not.  What you describe is
> > > > > > something else that would work on a per symbol basis, which would have to
> > > > > > be specified in a different way and might or might not be a good idea.
> > > > > > But let's not conflate these two.
> > > > >
> > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > particular unused symbol anyway. Since garbage collection only operates
> > > > > on the section level, marking the section itself as "retained" seems
> > > > > most appropriate.
> > > >
> > > > It can be done.  If you put your branch on
> > > >
> > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > >
> > > > I can help you implement it.
> > >
> > > It's not something I have time to look into at the moment, for now the
> > > aim is just to prevent garbage collection of sections.
> >
> > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> > to the framework.  Check how SHF_GNU_MBIND works.
>
> Sorry, I don't understand.
>
> Are you saying that LD already supports the garbage collection of
> individual unused symbol definitions from input sections? Whilst
> retaining other symbol definitions which are required by the program?
> I cannot find any reference to this.
>
> How does that relate to SHF_GNU_MBIND? I looked at all the references
> to "mbind" in Binutils and nothing seemed related garbage collection of
> sections, since SHF_GNU_MBIND is just used to indicate a particular
> section should be placed in a special memory area.

For

section .text,"ax"
   ...
foo:
  ...
 .section .text,"axR"
retained_fn:

you need to create a new .text section with SHF_GNU_RETAIN for
retained_fn.   See get_section in obj-elf.c.  If you want to avoid
merging .text section with SHF_GNU_RETAIN with other .text
sections by ld -r, linker needs to distinguish sections of the
same name with and without SHF_GNU_RETAIN.

-- 
H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Fangrui Song]

Hi Jozef,

I saw your proposal https://sourceware.org/pipermail/gnu-gabi/2020q3/000429.html
I did not subscribe to gnu-gabi before yesterday so it is inconvenient for me to
reply there. Since SHF_GNU_RETAIN is a new feature, and we already have facility
for making arbitrary sections alive with R_*_NONE, can you highlight the selling
point of a new flag?

Copying me previous reply here
> We already have a way to create an artificial reference:
> 
>   .reloc ., R_X86_64_NONE, target_symbol
> 
> If we allow a relocation number for the second operand
> 
>   .reloc ., 0, target_symbol
> 
> this will be generic. You can insert the directives in a GC root (e.g.
> _start or a symbol referenced by -u or maybe an .init_array)

If you do not want to touch the section containing the -e (--entry) symbol, you
can use:

   .section .init_array.1,"a",@init_array
   .reloc ., R_X86_64_NONE, retained_section

(I find that gold has an internal error with such a relocation.)
But GNU ld should have been supported this for a very long time.

(I added these directives to llvm last year: https://reviews.llvm.org/D62014 )

---

For a new section flag, there are a bunch of things needing thoughts

* assembler

The .retain directive seems to be discouraged... For section flags:

.section .foo,"a"
.section .foo,"aR"        # is this a new section
.pushsection .foo,"aR"    # is this a new section

Does the compiler need to remember that a section has the flag?
(Think how this works with __attribute__((section(...))); many asm streamers are
one-pass)

* linker
- What does -r do on two sections of the same, one with the flag and the other
without? (as HJ mentioned)
- Does the output section have the flag?
- Does the flag retain other sections in the same section group?


On 2020-09-23, H.J. Lu via Binutils wrote:
>On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
><jozef.l@mittosystems.com> wrote:
>>
>> On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
>> > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
>> > <jozef.l@mittosystems.com> wrote:
>> > >
>> > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
>> > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
>> > > > <jozef.l@mittosystems.com> wrote:
>> > > > >
>> > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
>> > > > > > Hello,
>> > > > > >
>> > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
>> > > > > >
>> > > > > > > > I think that:
>> > > > > > > >
>> > > > > > > > >  .section .text,"ax"
>> > > > > > > > >    ...
>> > > > > > > > >  foo:
>> > > > > > > > >    ...
>> > > > > > > > >  .retain
>> > > > > > > > >  retained_fn:
>> > > > > > > > >    ...
>> > > > > > > >
>> > > > > > > > is some nice syntactic sugar compared to:
>> > > > > > > >
>> > > > > > > > >  .section .text,"ax"
>> > > > > > > > >    ...
>> > > > > > > > >  foo:
>> > > > > > > > >    ...
>> > > > > > > > >  .section .text,"axR"
>> > > > > > > > >  retained_fn:
>> > > > > > > > >    ...
>> > > > > > > >
>> > > > > > > > It's also partly for convenience; we have other directives which are
>> > > > > > > > synonyms or short-hand for each other.
>> > > > > > > >
>> > > > > > >
>> > > > > > > You don't need to keep the whole section when only one symbol should
>> > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
>> > > > > > > right thing with
>> > > > > > >
>> > > > > > > .section .text,"ax"
>> > > > > > >    ...
>> > > > > > > foo:
>> > > > > > >   ...
>> > > > > > >  .section .text,"axR"
>> > > > > > >
>> > > > > > >  retained_fn:
>> > > > > > >
>> > > > > > > where foo can be dropped and retained_fn will be kept.
>> > > > > >
>> > > > > > This is not what we discussed at the ABI list, the flag is per section, so
>> > > > > > either the whole section is retained or not.  What you describe is
>> > > > > > something else that would work on a per symbol basis, which would have to
>> > > > > > be specified in a different way and might or might not be a good idea.
>> > > > > > But let's not conflate these two.
>> > > > >
>> > > > > Also, the linker cannot currently dissect a section and remove a
>> > > > > particular unused symbol anyway. Since garbage collection only operates
>> > > > > on the section level, marking the section itself as "retained" seems
>> > > > > most appropriate.
>> > > >
>> > > > It can be done.  If you put your branch on
>> > > >
>> > > > https://gitlab.com/x86-binutils/binutils-gdb
>> > > >
>> > > > I can help you implement it.
>> > >
>> > > It's not something I have time to look into at the moment, for now the
>> > > aim is just to prevent garbage collection of sections.
>> >
>> > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
>> > to the framework.  Check how SHF_GNU_MBIND works.
>>
>> Sorry, I don't understand.
>>
>> Are you saying that LD already supports the garbage collection of
>> individual unused symbol definitions from input sections? Whilst
>> retaining other symbol definitions which are required by the program?
>> I cannot find any reference to this.
>>
>> How does that relate to SHF_GNU_MBIND? I looked at all the references
>> to "mbind" in Binutils and nothing seemed related garbage collection of
>> sections, since SHF_GNU_MBIND is just used to indicate a particular
>> section should be placed in a special memory area.
>
>For
>
>section .text,"ax"
>   ...
>foo:
>  ...
> .section .text,"axR"
>retained_fn:
>
>you need to create a new .text section with SHF_GNU_RETAIN for
>retained_fn.   See get_section in obj-elf.c.  If you want to avoid
>merging .text section with SHF_GNU_RETAIN with other .text
>sections by ld -r, linker needs to distinguish sections of the
>same name with and without SHF_GNU_RETAIN.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Wed, Sep 23, 2020 at 04:29:43PM -0700, Fangrui Song wrote:
> Hi Jozef,

Hi Fangrui,

> I saw your proposal https://sourceware.org/pipermail/gnu-gabi/2020q3/000429.html
> I did not subscribe to gnu-gabi before yesterday so it is inconvenient for me to
> reply there. Since SHF_GNU_RETAIN is a new feature, and we already have facility
> for making arbitrary sections alive with R_*_NONE, can you highlight the selling
> point of a new flag?
> 
> Copying me previous reply here
> > We already have a way to create an artificial reference:
> > 
> >   .reloc ., R_X86_64_NONE, target_symbol
> > 
> > If we allow a relocation number for the second operand
> > 
> >   .reloc ., 0, target_symbol
> > 
> > this will be generic. You can insert the directives in a GC root (e.g.
> > _start or a symbol referenced by -u or maybe an .init_array)
> 
> If you do not want to touch the section containing the -e (--entry) symbol, you
> can use:
> 
>   .section .init_array.1,"a",@init_array
>   .reloc ., R_X86_64_NONE, retained_section
> 
> (I find that gold has an internal error with such a relocation.)
> But GNU ld should have been supported this for a very long time.
> 
> (I added these directives to llvm last year: https://reviews.llvm.org/D62014 )
> 

The fact that this relies on the compiler knowing a specific section
will be present in a linker script, when we are dealing with such a
broad ecosystem of targets and operating systems, makes me uneasy. The
functionality simply breaks if the user has a custom linker script which
does not have .init_array.

Many embedded applications can be written without requiring this
section. If someone has written their linker script from scratch, only
including the section directives for the sections they actually need,
why must we enforce that they have a .init_array input section rule just
so they can make use of the "retain" attribute. It doesn't make sense -
.init_array and "retain" are not related.

Even if this approach would work and pick the right section, I think
it is nicer for the user for the "retain" attribute to have a
dedicated ELF construct which describes the requirement to retain the
section, instead of using an existing construct whose purpose is not
related.

Your average user is going to be very confused why there are relocs in
section X which point to various symbols in their code. If they have
written the entire application, they might be able to infer that it is
the "retain" attribute which generated these relocs, but if someone else
wrote the code or the code is from a library or SDK it will not be
clear.

Ok we could maybe name a reloc like BFD_RELOC_RETAIN, but then what
would the description be?
  This relocation type does not actually perform any relocation action,
  but is used to indicate that the symbol it references should not be
  discarded by linker garbage collection. It must be placed in a section
  which will definitely be present in the linked output file, and not be
  subject to garbage collection, otherwise it will not have any effect.

Can you tell me why it is preferable to use the relocation mechanism to
implement this, instead of a precisely defined new section flag?

Why must we look to workarounds to implement something like this
anyway?  We can work out the details of a new section flag, and ensure
it is precisely specified to ensure robustness, and then developers can
benefit from understanding more about how their program has been put
together.

Do we want to make life easier for ourselves, or easier for our users?

I get that ABI changes can be a bit disruptive, but this new flag in
particular really isn't complicated anyway.

> ---
> 
> For a new section flag, there are a bunch of things needing thoughts
> 
> * assembler
> 
> The .retain directive seems to be discouraged... For section flags:
> 
> .section .foo,"a"
> .section .foo,"aR"        # is this a new section
> .pushsection .foo,"aR"    # is this a new section

No they are not new sections. From my original proposal:

> Alternatively, the "R" flag is recognized by the "flags" argument to the
> .section directive and will apply SHF_GNU_RETAIN to that section.
> It is intended that SHF_GNU_RETAIN does not interfere with any validation when
> switching to a section. It can be used to augment the section flags in a section
> which has already been created.

When you have two .section directives for the same section, GAS
"switches" between them instead of creating new sections, which is what
I referred to above.

This is why the .retain directive more precisely describes what is
happening. The compiler is telling the assembler that the section
containing the declaration of the function or data symbol should have
the SHF_GNU_RETAIN flag applied.

> 
> Does the compiler need to remember that a section has the flag?
> (Think how this works with __attribute__((section(...))); many asm streamers are
> one-pass)

The compiler does not need to worry about sections beyond getting the
name of the section the declaration is in. The "retain" attribute just
means that the section containing the declaration of the function or
data object must be retained, so it emits a directive to describe that.
Once the assembler has set SHF_GNU_RETAIN on a section, it will not be
unset.

I expect the most common use case to actually be when either the
"section" attribute has been used, or the -f{function,data}-sections GCC
options have been passed. If the user is trying to make the most out of
garbage collection, they should be using -f{function,data}-sections.

> 
> * linker
> - What does -r do on two sections of the same, one with the flag and the other
> without? (as HJ mentioned)

To reply to H.J. as well for this point:
I don't think this warrants any special behavior, SHF_GNU_RETAIN doesn't
need to change the behavior of section merging. The user should put the
object to retain in it's own section if they don't want large parts of
their program to possibly be unnecessarily retained. The unique section
name they give their SHF_GNU_RETAIN section will not be merged into a
general output section name until they perform the final non-relocatable
link.

A section with SHF_GNU_RETAIN applied is being retained because it
contains some information that is important to the program. So wherever
the that information ends up needs to be retained.

> - Does the output section have the flag?

SHF_GNU_RETAIN is applied to an input section.
To ensure the input section is retained, SHF_GNU_RETAIN must be applied
to any section that input section is merged with. The flag doesn't get
removed from output sections.

> - Does the flag retain other sections in the same section group?

Yes.
From the description on section groups from the ELF spec:
  ... such groups must be included or omitted from the linked
  object as a unit.

I think potentially the only confusing part of any section flag merging
behavior is the fact that the assembly code might have different
.section directives for the same section, some with "R" and some without
(+1 for a .retain directive ;)).
Once the assembler has emitted its output, the SHF_GNU_RETAIN flag
applied to an input section behaves like any other section flag.
There is only one line of linker code which does anything specific with
SHF_GNU_RETAIN, and that is the code in bfd/elflink.c to "gc_mark" the
section.

Thanks,
Jozef

> 
> 
> On 2020-09-23, H.J. Lu via Binutils wrote:
> > On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
> > <jozef.l@mittosystems.com> wrote:
> > > 
> > > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > > > <jozef.l@mittosystems.com> wrote:
> > > > >
> > > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > >
> > > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > > > Hello,
> > > > > > > >
> > > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > > > >
> > > > > > > > > > I think that:
> > > > > > > > > >
> > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > >    ...
> > > > > > > > > > >  foo:
> > > > > > > > > > >    ...
> > > > > > > > > > >  .retain
> > > > > > > > > > >  retained_fn:
> > > > > > > > > > >    ...
> > > > > > > > > >
> > > > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > > > >
> > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > >    ...
> > > > > > > > > > >  foo:
> > > > > > > > > > >    ...
> > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > >  retained_fn:
> > > > > > > > > > >    ...
> > > > > > > > > >
> > > > > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > > > > synonyms or short-hand for each other.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > > > > right thing with
> > > > > > > > >
> > > > > > > > > .section .text,"ax"
> > > > > > > > >    ...
> > > > > > > > > foo:
> > > > > > > > >   ...
> > > > > > > > >  .section .text,"axR"
> > > > > > > > >
> > > > > > > > >  retained_fn:
> > > > > > > > >
> > > > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > > > >
> > > > > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > > > > either the whole section is retained or not.  What you describe is
> > > > > > > > something else that would work on a per symbol basis, which would have to
> > > > > > > > be specified in a different way and might or might not be a good idea.
> > > > > > > > But let's not conflate these two.
> > > > > > >
> > > > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > > > particular unused symbol anyway. Since garbage collection only operates
> > > > > > > on the section level, marking the section itself as "retained" seems
> > > > > > > most appropriate.
> > > > > >
> > > > > > It can be done.  If you put your branch on
> > > > > >
> > > > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > > > >
> > > > > > I can help you implement it.
> > > > >
> > > > > It's not something I have time to look into at the moment, for now the
> > > > > aim is just to prevent garbage collection of sections.
> > > >
> > > > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> > > > to the framework.  Check how SHF_GNU_MBIND works.
> > > 
> > > Sorry, I don't understand.
> > > 
> > > Are you saying that LD already supports the garbage collection of
> > > individual unused symbol definitions from input sections? Whilst
> > > retaining other symbol definitions which are required by the program?
> > > I cannot find any reference to this.
> > > 
> > > How does that relate to SHF_GNU_MBIND? I looked at all the references
> > > to "mbind" in Binutils and nothing seemed related garbage collection of
> > > sections, since SHF_GNU_MBIND is just used to indicate a particular
> > > section should be placed in a special memory area.
> > 
> > For
> > 
> > section .text,"ax"
> >   ...
> > foo:
> >  ...
> > .section .text,"axR"
> > retained_fn:
> > 
> > you need to create a new .text section with SHF_GNU_RETAIN for
> > retained_fn.   See get_section in obj-elf.c.  If you want to avoid
> > merging .text section with SHF_GNU_RETAIN with other .text
> > sections by ld -r, linker needs to distinguish sections of the
> > same name with and without SHF_GNU_RETAIN.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Fangrui Song]

On 2020-09-24, Jozef Lawrynowicz wrote:
>On Wed, Sep 23, 2020 at 04:29:43PM -0700, Fangrui Song wrote:
>> Hi Jozef,
>
>Hi Fangrui,
>
>> I saw your proposal https://sourceware.org/pipermail/gnu-gabi/2020q3/000429.html
>> I did not subscribe to gnu-gabi before yesterday so it is inconvenient for me to
>> reply there. Since SHF_GNU_RETAIN is a new feature, and we already have facility
>> for making arbitrary sections alive with R_*_NONE, can you highlight the selling
>> point of a new flag?
>>
>> Copying me previous reply here
>> > We already have a way to create an artificial reference:
>> >
>> >   .reloc ., R_X86_64_NONE, target_symbol
>> >
>> > If we allow a relocation number for the second operand
>> >
>> >   .reloc ., 0, target_symbol
>> >
>> > this will be generic. You can insert the directives in a GC root (e.g.
>> > _start or a symbol referenced by -u or maybe an .init_array)
>>
>> If you do not want to touch the section containing the -e (--entry) symbol, you
>> can use:
>>
>>   .section .init_array.1,"a",@init_array
>>   .reloc ., R_X86_64_NONE, retained_section
>>
>> (I find that gold has an internal error with such a relocation.)
>> But GNU ld should have been supported this for a very long time.
>>
>> (I added these directives to llvm last year: https://reviews.llvm.org/D62014 )
>>
>
>The fact that this relies on the compiler knowing a specific section
>will be present in a linker script, when we are dealing with such a
>broad ecosystem of targets and operating systems, makes me uneasy. The
>functionality simply breaks if the user has a custom linker script which
>does not have .init_array.
>
>Many embedded applications can be written without requiring this
>section. If someone has written their linker script from scratch, only
>including the section directives for the sections they actually need,
>why must we enforce that they have a .init_array input section rule just
>so they can make use of the "retain" attribute. It doesn't make sense -
>.init_array and "retain" are not related.

I use .init_array (which happens to be a GC root) as an example, not
that I am advertising .init_array . My main point is about .reloc
You can use a .reloc directive in a known GC root. .init_array happens
to be such a GC root so I used it as an example. It is not too bad if
you think about a benign zero-sized section.

>Even if this approach would work and pick the right section, I think
>it is nicer for the user for the "retain" attribute to have a
>dedicated ELF construct which describes the requirement to retain the
>section, instead of using an existing construct whose purpose is not
>related.

Relocations are the keystone of --gc-sections. In some cases we want a
dependency relation but do not want the relocation to alter the content.
We use R_*_NONE in such cases.

A relocation gives more control than a section flag. In cases you need
"if this section is retained, please retain some other sections",
instead of "please always retain these sections".

>Your average user is going to be very confused why there are relocs in
>section X which point to various symbols in their code. If they have
>written the entire application, they might be able to infer that it is
>the "retain" attribute which generated these relocs, but if someone else
>wrote the code or the code is from a library or SDK it will not be
>clear.
>
>Ok we could maybe name a reloc like BFD_RELOC_RETAIN, but then what
>would the description be?
>  This relocation type does not actually perform any relocation action,
>  but is used to indicate that the symbol it references should not be
>  discarded by linker garbage collection. It must be placed in a section
>  which will definitely be present in the linked output file, and not be
>  subject to garbage collection, otherwise it will not have any effect.
>
>Can you tell me why it is preferable to use the relocation mechanism to
>implement this, instead of a precisely defined new section flag?
>
>Why must we look to workarounds to implement something like this
>anyway?  We can work out the details of a new section flag, and ensure
>it is precisely specified to ensure robustness, and then developers can
>benefit from understanding more about how their program has been put
>together.
>
>Do we want to make life easier for ourselves, or easier for our users?
>
>I get that ABI changes can be a bit disruptive, but this new flag in
>particular really isn't complicated anyway.
>
>> ---
>>
>> For a new section flag, there are a bunch of things needing thoughts
>>
>> * assembler
>>
>> The .retain directive seems to be discouraged... For section flags:
>>
>> .section .foo,"a"
>> .section .foo,"aR"        # is this a new section
>> .pushsection .foo,"aR"    # is this a new section
>
>No they are not new sections. From my original proposal:

If we use a section flag, my expected behavior for the second .section
with different flags is an error:
https://sourceware.org/pipermail/binutils/2020-February/109945.html

>> .section .foo,"a"
>> .section .foo,"aR"        # error

In this case, I agree that a separate directive can be more convenient
because the compiler does not need to known the flag when it is about to
emit the first .section directive (for example, due to a faraway __attribute__((section(...))))

But then, it will be an innovation I don't know a precedent exists.

>> Alternatively, the "R" flag is recognized by the "flags" argument to the
>> .section directive and will apply SHF_GNU_RETAIN to that section.
>> It is intended that SHF_GNU_RETAIN does not interfere with any validation when
>> switching to a section. It can be used to augment the section flags in a section
>> which has already been created.
>
>When you have two .section directives for the same section, GAS
>"switches" between them instead of creating new sections, which is what
>I referred to above.
>
>This is why the .retain directive more precisely describes what is
>happening. The compiler is telling the assembler that the section
>containing the declaration of the function or data symbol should have
>the SHF_GNU_RETAIN flag applied.
>
>>
>> Does the compiler need to remember that a section has the flag?
>> (Think how this works with __attribute__((section(...))); many asm streamers are
>> one-pass)
>
>The compiler does not need to worry about sections beyond getting the
>name of the section the declaration is in. The "retain" attribute just
>means that the section containing the declaration of the function or
>data object must be retained, so it emits a directive to describe that.
>Once the assembler has set SHF_GNU_RETAIN on a section, it will not be
>unset.
>
>I expect the most common use case to actually be when either the
>"section" attribute has been used, or the -f{function,data}-sections GCC
>options have been passed. If the user is trying to make the most out of
>garbage collection, they should be using -f{function,data}-sections.
>
>>
>> * linker
>> - What does -r do on two sections of the same, one with the flag and the other
>> without? (as HJ mentioned)
>
>To reply to H.J. as well for this point:
>I don't think this warrants any special behavior, SHF_GNU_RETAIN doesn't
>need to change the behavior of section merging. The user should put the
>object to retain in it's own section if they don't want large parts of
>their program to possibly be unnecessarily retained. The unique section
>name they give their SHF_GNU_RETAIN section will not be merged into a
>general output section name until they perform the final non-relocatable
>link.
>
>A section with SHF_GNU_RETAIN applied is being retained because it
>contains some information that is important to the program. So wherever
>the that information ends up needs to be retained.
>
>> - Does the output section have the flag?
>
>SHF_GNU_RETAIN is applied to an input section.
>To ensure the input section is retained, SHF_GNU_RETAIN must be applied
>to any section that input section is merged with. The flag doesn't get
>removed from output sections.
>
>> - Does the flag retain other sections in the same section group?
>
>Yes.
From the description on section groups from the ELF spec:
>  ... such groups must be included or omitted from the linked
>  object as a unit.
>
>I think potentially the only confusing part of any section flag merging
>behavior is the fact that the assembly code might have different
>.section directives for the same section, some with "R" and some without
>(+1 for a .retain directive ;)).
>Once the assembler has emitted its output, the SHF_GNU_RETAIN flag
>applied to an input section behaves like any other section flag.
>There is only one line of linker code which does anything specific with
>SHF_GNU_RETAIN, and that is the code in bfd/elflink.c to "gc_mark" the
>section.
>
>Thanks,
>Jozef
>
>>
>>
>> On 2020-09-23, H.J. Lu via Binutils wrote:
>> > On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
>> > <jozef.l@mittosystems.com> wrote:
>> > >
>> > > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
>> > > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
>> > > > <jozef.l@mittosystems.com> wrote:
>> > > > >
>> > > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
>> > > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
>> > > > > > <jozef.l@mittosystems.com> wrote:
>> > > > > > >
>> > > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
>> > > > > > > > Hello,
>> > > > > > > >
>> > > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
>> > > > > > > >
>> > > > > > > > > > I think that:
>> > > > > > > > > >
>> > > > > > > > > > >  .section .text,"ax"
>> > > > > > > > > > >    ...
>> > > > > > > > > > >  foo:
>> > > > > > > > > > >    ...
>> > > > > > > > > > >  .retain
>> > > > > > > > > > >  retained_fn:
>> > > > > > > > > > >    ...
>> > > > > > > > > >
>> > > > > > > > > > is some nice syntactic sugar compared to:
>> > > > > > > > > >
>> > > > > > > > > > >  .section .text,"ax"
>> > > > > > > > > > >    ...
>> > > > > > > > > > >  foo:
>> > > > > > > > > > >    ...
>> > > > > > > > > > >  .section .text,"axR"
>> > > > > > > > > > >  retained_fn:
>> > > > > > > > > > >    ...
>> > > > > > > > > >
>> > > > > > > > > > It's also partly for convenience; we have other directives which are
>> > > > > > > > > > synonyms or short-hand for each other.
>> > > > > > > > > >
>> > > > > > > > >
>> > > > > > > > > You don't need to keep the whole section when only one symbol should
>> > > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
>> > > > > > > > > right thing with
>> > > > > > > > >
>> > > > > > > > > .section .text,"ax"
>> > > > > > > > >    ...
>> > > > > > > > > foo:
>> > > > > > > > >   ...
>> > > > > > > > >  .section .text,"axR"
>> > > > > > > > >
>> > > > > > > > >  retained_fn:
>> > > > > > > > >
>> > > > > > > > > where foo can be dropped and retained_fn will be kept.
>> > > > > > > >
>> > > > > > > > This is not what we discussed at the ABI list, the flag is per section, so
>> > > > > > > > either the whole section is retained or not.  What you describe is
>> > > > > > > > something else that would work on a per symbol basis, which would have to
>> > > > > > > > be specified in a different way and might or might not be a good idea.
>> > > > > > > > But let's not conflate these two.
>> > > > > > >
>> > > > > > > Also, the linker cannot currently dissect a section and remove a
>> > > > > > > particular unused symbol anyway. Since garbage collection only operates
>> > > > > > > on the section level, marking the section itself as "retained" seems
>> > > > > > > most appropriate.
>> > > > > >
>> > > > > > It can be done.  If you put your branch on
>> > > > > >
>> > > > > > https://gitlab.com/x86-binutils/binutils-gdb
>> > > > > >
>> > > > > > I can help you implement it.
>> > > > >
>> > > > > It's not something I have time to look into at the moment, for now the
>> > > > > aim is just to prevent garbage collection of sections.
>> > > >
>> > > > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
>> > > > to the framework.  Check how SHF_GNU_MBIND works.
>> > >
>> > > Sorry, I don't understand.
>> > >
>> > > Are you saying that LD already supports the garbage collection of
>> > > individual unused symbol definitions from input sections? Whilst
>> > > retaining other symbol definitions which are required by the program?
>> > > I cannot find any reference to this.
>> > >
>> > > How does that relate to SHF_GNU_MBIND? I looked at all the references
>> > > to "mbind" in Binutils and nothing seemed related garbage collection of
>> > > sections, since SHF_GNU_MBIND is just used to indicate a particular
>> > > section should be placed in a special memory area.
>> >
>> > For
>> >
>> > section .text,"ax"
>> >   ...
>> > foo:
>> >  ...
>> > .section .text,"axR"
>> > retained_fn:
>> >
>> > you need to create a new .text section with SHF_GNU_RETAIN for
>> > retained_fn.   See get_section in obj-elf.c.  If you want to avoid
>> > merging .text section with SHF_GNU_RETAIN with other .text
>> > sections by ld -r, linker needs to distinguish sections of the
>> > same name with and without SHF_GNU_RETAIN.
>

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Michael Matz]

Hello,

On Wed, 23 Sep 2020, Fangrui Song wrote:

> Since SHF_GNU_RETAIN is a new feature, and we already have facility for 
> making arbitrary sections alive with R_*_NONE, can you highlight the 
> selling point of a new flag?

I wouldn't call this a facility.  I call it a hack that accidentally works 
for this purpose.

> Copying me previous reply here
> > We already have a way to create an artificial reference:
> > 
> >   .reloc ., R_X86_64_NONE, target_symbol
> > 
> > If we allow a relocation number for the second operand
> > 
> >   .reloc ., 0, target_symbol
> > 
> > this will be generic. You can insert the directives in a GC root (e.g.
> > _start or a symbol referenced by -u or maybe an .init_array)
> 
> If you do not want to touch the section containing the -e (--entry) symbol,
> you
> can use:
> 
>   .section .init_array.1,"a",@init_array
>   .reloc ., R_X86_64_NONE, retained_section

And what makes .init_array be retained?  To which data item does the 
relocation apply, what if .init_array is empty?  I think using this to 
force sections be retained is a terrible idea (I was split minds about 
calling this idea cute vs. terrible ;-) ).

> For a new section flag, there are a bunch of things needing thoughts

I think the answer to each of these things is obvious:

> * assembler
> 
> The .retain directive seems to be discouraged... For section flags:
> 
> .section .foo,"a"
> .section .foo,"aR"        # is this a new section
> .pushsection .foo,"aR"    # is this a new section
> 
> Does the compiler need to remember that a section has the flag?

Why should it need to remember?  (E.g. GCC does, but why would it matter?)  
The assembler merges the flags, no need to remember things.

> * linker
> - What does -r do on two sections of the same, one with the flag and the other
> without? (as HJ mentioned)

It merges the flag with logical or.

> - Does the output section have the flag?

Yes.

> - Does the flag retain other sections in the same section group?

Yes.


Ciao,
Michael.

> 
> 
> On 2020-09-23, H.J. Lu via Binutils wrote:
> > On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
> > <jozef.l@mittosystems.com> wrote:
> > > 
> > > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > > > <jozef.l@mittosystems.com> wrote:
> > > > >
> > > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > >
> > > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > > > Hello,
> > > > > > > >
> > > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > > > >
> > > > > > > > > > I think that:
> > > > > > > > > >
> > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > >    ...
> > > > > > > > > > >  foo:
> > > > > > > > > > >    ...
> > > > > > > > > > >  .retain
> > > > > > > > > > >  retained_fn:
> > > > > > > > > > >    ...
> > > > > > > > > >
> > > > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > > > >
> > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > >    ...
> > > > > > > > > > >  foo:
> > > > > > > > > > >    ...
> > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > >  retained_fn:
> > > > > > > > > > >    ...
> > > > > > > > > >
> > > > > > > > > > It's also partly for convenience; we have other directives
> > > which are
> > > > > > > > > > synonyms or short-hand for each other.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You don't need to keep the whole section when only one symbol
> > > should
> > > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld
> > > should do the
> > > > > > > > > right thing with
> > > > > > > > >
> > > > > > > > > .section .text,"ax"
> > > > > > > > >    ...
> > > > > > > > > foo:
> > > > > > > > >   ...
> > > > > > > > >  .section .text,"axR"
> > > > > > > > >
> > > > > > > > >  retained_fn:
> > > > > > > > >
> > > > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > > > >
> > > > > > > > This is not what we discussed at the ABI list, the flag is per
> > > section, so
> > > > > > > > either the whole section is retained or not.  What you describe
> > > is
> > > > > > > > something else that would work on a per symbol basis, which
> > > would have to
> > > > > > > > be specified in a different way and might or might not be a good
> > > idea.
> > > > > > > > But let's not conflate these two.
> > > > > > >
> > > > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > > > particular unused symbol anyway. Since garbage collection only
> > > operates
> > > > > > > on the section level, marking the section itself as "retained"
> > > seems
> > > > > > > most appropriate.
> > > > > >
> > > > > > It can be done.  If you put your branch on
> > > > > >
> > > > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > > > >
> > > > > > I can help you implement it.
> > > > >
> > > > > It's not something I have time to look into at the moment, for now the
> > > > > aim is just to prevent garbage collection of sections.
> > > >
> > > > Linker and assembler already support it.   You just need to add
> > > SHF_GNU_RETAIN
> > > > to the framework.  Check how SHF_GNU_MBIND works.
> > > 
> > > Sorry, I don't understand.
> > > 
> > > Are you saying that LD already supports the garbage collection of
> > > individual unused symbol definitions from input sections? Whilst
> > > retaining other symbol definitions which are required by the program?
> > > I cannot find any reference to this.
> > > 
> > > How does that relate to SHF_GNU_MBIND? I looked at all the references
> > > to "mbind" in Binutils and nothing seemed related garbage collection of
> > > sections, since SHF_GNU_MBIND is just used to indicate a particular
> > > section should be placed in a special memory area.
> > 
> > For
> > 
> > section .text,"ax"
> >   ...
> > foo:
> >  ...
> > .section .text,"axR"
> > retained_fn:
> > 
> > you need to create a new .text section with SHF_GNU_RETAIN for
> > retained_fn.   See get_section in obj-elf.c.  If you want to avoid
> > merging .text section with SHF_GNU_RETAIN with other .text
> > sections by ld -r, linker needs to distinguish sections of the
> > same name with and without SHF_GNU_RETAIN.
> 

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[H.J. Lu]

On Wed, Sep 23, 2020 at 1:17 PM H.J. Lu <hjl.tools@gmail.com> wrote:
>
> On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
> <jozef.l@mittosystems.com> wrote:
> >
> > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > > <jozef.l@mittosystems.com> wrote:
> > > >
> > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > > <jozef.l@mittosystems.com> wrote:
> > > > > >
> > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > > Hello,
> > > > > > >
> > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > > >
> > > > > > > > > I think that:
> > > > > > > > >
> > > > > > > > > >  .section .text,"ax"
> > > > > > > > > >    ...
> > > > > > > > > >  foo:
> > > > > > > > > >    ...
> > > > > > > > > >  .retain
> > > > > > > > > >  retained_fn:
> > > > > > > > > >    ...
> > > > > > > > >
> > > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > > >
> > > > > > > > > >  .section .text,"ax"
> > > > > > > > > >    ...
> > > > > > > > > >  foo:
> > > > > > > > > >    ...
> > > > > > > > > >  .section .text,"axR"
> > > > > > > > > >  retained_fn:
> > > > > > > > > >    ...
> > > > > > > > >
> > > > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > > > synonyms or short-hand for each other.
> > > > > > > > >
> > > > > > > >
> > > > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > > > right thing with
> > > > > > > >
> > > > > > > > .section .text,"ax"
> > > > > > > >    ...
> > > > > > > > foo:
> > > > > > > >   ...
> > > > > > > >  .section .text,"axR"
> > > > > > > >
> > > > > > > >  retained_fn:
> > > > > > > >
> > > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > > >
> > > > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > > > either the whole section is retained or not.  What you describe is
> > > > > > > something else that would work on a per symbol basis, which would have to
> > > > > > > be specified in a different way and might or might not be a good idea.
> > > > > > > But let's not conflate these two.
> > > > > >
> > > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > > particular unused symbol anyway. Since garbage collection only operates
> > > > > > on the section level, marking the section itself as "retained" seems
> > > > > > most appropriate.
> > > > >
> > > > > It can be done.  If you put your branch on
> > > > >
> > > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > > >
> > > > > I can help you implement it.
> > > >
> > > > It's not something I have time to look into at the moment, for now the
> > > > aim is just to prevent garbage collection of sections.
> > >
> > > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> > > to the framework.  Check how SHF_GNU_MBIND works.
> >
> > Sorry, I don't understand.
> >
> > Are you saying that LD already supports the garbage collection of
> > individual unused symbol definitions from input sections? Whilst
> > retaining other symbol definitions which are required by the program?
> > I cannot find any reference to this.
> >
> > How does that relate to SHF_GNU_MBIND? I looked at all the references
> > to "mbind" in Binutils and nothing seemed related garbage collection of
> > sections, since SHF_GNU_MBIND is just used to indicate a particular
> > section should be placed in a special memory area.
>
> For
>
> section .text,"ax"
>    ...
> foo:
>   ...
>  .section .text,"axR"
> retained_fn:
>
> you need to create a new .text section with SHF_GNU_RETAIN for
> retained_fn.   See get_section in obj-elf.c.  If you want to avoid

See users/hjl/elf/master branch at:

https://gitlab.com/x86-binutils/binutils-gdb/-/commits/users/hjl/elf/master

I removed the .retain directive.

> merging .text section with SHF_GNU_RETAIN with other .text
> sections by ld -r, linker needs to distinguish sections of the
> same name with and without SHF_GNU_RETAIN.
>
> --
> H.J.



-- 
H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Thu, Sep 24, 2020 at 06:18:05AM -0700, H.J. Lu via Binutils wrote:
> On Wed, Sep 23, 2020 at 1:17 PM H.J. Lu <hjl.tools@gmail.com> wrote:
> >
> > On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
> > <jozef.l@mittosystems.com> wrote:
> > >
> > > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > > > <jozef.l@mittosystems.com> wrote:
> > > > >
> > > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > >
> > > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > > > Hello,
> > > > > > > >
> > > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > > > >
> > > > > > > > > > I think that:
> > > > > > > > > >
> > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > >    ...
> > > > > > > > > > >  foo:
> > > > > > > > > > >    ...
> > > > > > > > > > >  .retain
> > > > > > > > > > >  retained_fn:
> > > > > > > > > > >    ...
> > > > > > > > > >
> > > > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > > > >
> > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > >    ...
> > > > > > > > > > >  foo:
> > > > > > > > > > >    ...
> > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > >  retained_fn:
> > > > > > > > > > >    ...
> > > > > > > > > >
> > > > > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > > > > synonyms or short-hand for each other.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > > > > right thing with
> > > > > > > > >
> > > > > > > > > .section .text,"ax"
> > > > > > > > >    ...
> > > > > > > > > foo:
> > > > > > > > >   ...
> > > > > > > > >  .section .text,"axR"
> > > > > > > > >
> > > > > > > > >  retained_fn:
> > > > > > > > >
> > > > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > > > >
> > > > > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > > > > either the whole section is retained or not.  What you describe is
> > > > > > > > something else that would work on a per symbol basis, which would have to
> > > > > > > > be specified in a different way and might or might not be a good idea.
> > > > > > > > But let's not conflate these two.
> > > > > > >
> > > > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > > > particular unused symbol anyway. Since garbage collection only operates
> > > > > > > on the section level, marking the section itself as "retained" seems
> > > > > > > most appropriate.
> > > > > >
> > > > > > It can be done.  If you put your branch on
> > > > > >
> > > > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > > > >
> > > > > > I can help you implement it.
> > > > >
> > > > > It's not something I have time to look into at the moment, for now the
> > > > > aim is just to prevent garbage collection of sections.
> > > >
> > > > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> > > > to the framework.  Check how SHF_GNU_MBIND works.
> > >
> > > Sorry, I don't understand.
> > >
> > > Are you saying that LD already supports the garbage collection of
> > > individual unused symbol definitions from input sections? Whilst
> > > retaining other symbol definitions which are required by the program?
> > > I cannot find any reference to this.
> > >
> > > How does that relate to SHF_GNU_MBIND? I looked at all the references
> > > to "mbind" in Binutils and nothing seemed related garbage collection of
> > > sections, since SHF_GNU_MBIND is just used to indicate a particular
> > > section should be placed in a special memory area.
> >
> > For
> >
> > section .text,"ax"
> >    ...
> > foo:
> >   ...
> >  .section .text,"axR"
> > retained_fn:
> >
> > you need to create a new .text section with SHF_GNU_RETAIN for
> > retained_fn.   See get_section in obj-elf.c.  If you want to avoid
> 
> See users/hjl/elf/master branch at:
> 
> https://gitlab.com/x86-binutils/binutils-gdb/-/commits/users/hjl/elf/master
> 
> I removed the .retain directive.

Thanks, the formalization of section flag merging in the assembler is
nice.

My only comment is that I used the "STT_*" syntax in the .type directive
instead of % because some targets didn't like the % syntax and emmited
an error. I don't remember which, maybe it was mmix-elf, in which case
we don't care :)

When I re-test I'll see if the errors pop up again.

I still need to add the GNU OSABI handling, but with that and your
patches we are probably ready to apply after a final official sign-off.

How would that work logistically, I apply my patch and you apply yours
after? Or do we align off-master and apply as one patch?

Thanks,
Jozef

> 
> > merging .text section with SHF_GNU_RETAIN with other .text
> > sections by ld -r, linker needs to distinguish sections of the
> > same name with and without SHF_GNU_RETAIN.
> >
> > --
> > H.J.
> 
> 
> 
> -- 
> H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[H.J. Lu]

On Thu, Sep 24, 2020 at 6:49 AM Jozef Lawrynowicz
<jozef.l@mittosystems.com> wrote:
>
> On Thu, Sep 24, 2020 at 06:18:05AM -0700, H.J. Lu via Binutils wrote:
> > On Wed, Sep 23, 2020 at 1:17 PM H.J. Lu <hjl.tools@gmail.com> wrote:
> > >
> > > On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
> > > <jozef.l@mittosystems.com> wrote:
> > > >
> > > > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > > > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > > > > <jozef.l@mittosystems.com> wrote:
> > > > > >
> > > > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > > >
> > > > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > > > > Hello,
> > > > > > > > >
> > > > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > > > > >
> > > > > > > > > > > I think that:
> > > > > > > > > > >
> > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > >    ...
> > > > > > > > > > > >  foo:
> > > > > > > > > > > >    ...
> > > > > > > > > > > >  .retain
> > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > >    ...
> > > > > > > > > > >
> > > > > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > > > > >
> > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > >    ...
> > > > > > > > > > > >  foo:
> > > > > > > > > > > >    ...
> > > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > >    ...
> > > > > > > > > > >
> > > > > > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > > > > > synonyms or short-hand for each other.
> > > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > > > > > right thing with
> > > > > > > > > >
> > > > > > > > > > .section .text,"ax"
> > > > > > > > > >    ...
> > > > > > > > > > foo:
> > > > > > > > > >   ...
> > > > > > > > > >  .section .text,"axR"
> > > > > > > > > >
> > > > > > > > > >  retained_fn:
> > > > > > > > > >
> > > > > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > > > > >
> > > > > > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > > > > > either the whole section is retained or not.  What you describe is
> > > > > > > > > something else that would work on a per symbol basis, which would have to
> > > > > > > > > be specified in a different way and might or might not be a good idea.
> > > > > > > > > But let's not conflate these two.
> > > > > > > >
> > > > > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > > > > particular unused symbol anyway. Since garbage collection only operates
> > > > > > > > on the section level, marking the section itself as "retained" seems
> > > > > > > > most appropriate.
> > > > > > >
> > > > > > > It can be done.  If you put your branch on
> > > > > > >
> > > > > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > > > > >
> > > > > > > I can help you implement it.
> > > > > >
> > > > > > It's not something I have time to look into at the moment, for now the
> > > > > > aim is just to prevent garbage collection of sections.
> > > > >
> > > > > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> > > > > to the framework.  Check how SHF_GNU_MBIND works.
> > > >
> > > > Sorry, I don't understand.
> > > >
> > > > Are you saying that LD already supports the garbage collection of
> > > > individual unused symbol definitions from input sections? Whilst
> > > > retaining other symbol definitions which are required by the program?
> > > > I cannot find any reference to this.
> > > >
> > > > How does that relate to SHF_GNU_MBIND? I looked at all the references
> > > > to "mbind" in Binutils and nothing seemed related garbage collection of
> > > > sections, since SHF_GNU_MBIND is just used to indicate a particular
> > > > section should be placed in a special memory area.
> > >
> > > For
> > >
> > > section .text,"ax"
> > >    ...
> > > foo:
> > >   ...
> > >  .section .text,"axR"
> > > retained_fn:
> > >
> > > you need to create a new .text section with SHF_GNU_RETAIN for
> > > retained_fn.   See get_section in obj-elf.c.  If you want to avoid
> >
> > See users/hjl/elf/master branch at:
> >
> > https://gitlab.com/x86-binutils/binutils-gdb/-/commits/users/hjl/elf/master
> >
> > I removed the .retain directive.
>
> Thanks, the formalization of section flag merging in the assembler is
> nice.
>
> My only comment is that I used the "STT_*" syntax in the .type directive
> instead of % because some targets didn't like the % syntax and emmited
> an error. I don't remember which, maybe it was mmix-elf, in which case
> we don't care :)

Some targets don't support @object.  %object works for all targets.

> When I re-test I'll see if the errors pop up again.
>
> I still need to add the GNU OSABI handling, but with that and your
> patches we are probably ready to apply after a final official sign-off.
>
> How would that work logistically, I apply my patch and you apply yours
> after? Or do we align off-master and apply as one patch?
>

Please get an account on gitlab.com and send me your account name.
Then you can put your branch in

https://gitlab.com/x86-binutils/binutils-gdb

and we can work together to finish it.


--
H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Thu, Sep 24, 2020 at 06:59:07AM -0700, H.J. Lu via Binutils wrote:
> On Thu, Sep 24, 2020 at 6:49 AM Jozef Lawrynowicz
> <jozef.l@mittosystems.com> wrote:
> >
> > On Thu, Sep 24, 2020 at 06:18:05AM -0700, H.J. Lu via Binutils wrote:
> > > On Wed, Sep 23, 2020 at 1:17 PM H.J. Lu <hjl.tools@gmail.com> wrote:
> > > >
> > > > On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
> > > > <jozef.l@mittosystems.com> wrote:
> > > > >
> > > > > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > > > > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > >
> > > > > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > > > >
> > > > > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > > > > > Hello,
> > > > > > > > > >
> > > > > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > > > > > >
> > > > > > > > > > > > I think that:
> > > > > > > > > > > >
> > > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > > >    ...
> > > > > > > > > > > > >  foo:
> > > > > > > > > > > > >    ...
> > > > > > > > > > > > >  .retain
> > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > >    ...
> > > > > > > > > > > >
> > > > > > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > > > > > >
> > > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > > >    ...
> > > > > > > > > > > > >  foo:
> > > > > > > > > > > > >    ...
> > > > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > >    ...
> > > > > > > > > > > >
> > > > > > > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > > > > > > synonyms or short-hand for each other.
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > > > > > > right thing with
> > > > > > > > > > >
> > > > > > > > > > > .section .text,"ax"
> > > > > > > > > > >    ...
> > > > > > > > > > > foo:
> > > > > > > > > > >   ...
> > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > >
> > > > > > > > > > >  retained_fn:
> > > > > > > > > > >
> > > > > > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > > > > > >
> > > > > > > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > > > > > > either the whole section is retained or not.  What you describe is
> > > > > > > > > > something else that would work on a per symbol basis, which would have to
> > > > > > > > > > be specified in a different way and might or might not be a good idea.
> > > > > > > > > > But let's not conflate these two.
> > > > > > > > >
> > > > > > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > > > > > particular unused symbol anyway. Since garbage collection only operates
> > > > > > > > > on the section level, marking the section itself as "retained" seems
> > > > > > > > > most appropriate.
> > > > > > > >
> > > > > > > > It can be done.  If you put your branch on
> > > > > > > >
> > > > > > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > > > > > >
> > > > > > > > I can help you implement it.
> > > > > > >
> > > > > > > It's not something I have time to look into at the moment, for now the
> > > > > > > aim is just to prevent garbage collection of sections.
> > > > > >
> > > > > > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> > > > > > to the framework.  Check how SHF_GNU_MBIND works.
> > > > >
> > > > > Sorry, I don't understand.
> > > > >
> > > > > Are you saying that LD already supports the garbage collection of
> > > > > individual unused symbol definitions from input sections? Whilst
> > > > > retaining other symbol definitions which are required by the program?
> > > > > I cannot find any reference to this.
> > > > >
> > > > > How does that relate to SHF_GNU_MBIND? I looked at all the references
> > > > > to "mbind" in Binutils and nothing seemed related garbage collection of
> > > > > sections, since SHF_GNU_MBIND is just used to indicate a particular
> > > > > section should be placed in a special memory area.
> > > >
> > > > For
> > > >
> > > > section .text,"ax"
> > > >    ...
> > > > foo:
> > > >   ...
> > > >  .section .text,"axR"
> > > > retained_fn:
> > > >
> > > > you need to create a new .text section with SHF_GNU_RETAIN for
> > > > retained_fn.   See get_section in obj-elf.c.  If you want to avoid
> > >
> > > See users/hjl/elf/master branch at:
> > >
> > > https://gitlab.com/x86-binutils/binutils-gdb/-/commits/users/hjl/elf/master
> > >
> > > I removed the .retain directive.
> >
> > Thanks, the formalization of section flag merging in the assembler is
> > nice.
> >
> > My only comment is that I used the "STT_*" syntax in the .type directive
> > instead of % because some targets didn't like the % syntax and emmited
> > an error. I don't remember which, maybe it was mmix-elf, in which case
> > we don't care :)
> 
> Some targets don't support @object.  %object works for all targets.

Ah yes, it is in fact the non-existent mmix-elf that can't assemble
%object but it works for all real targets.

However, some targets don't support the .bss pseudo op which is used in
your new tests, so those are failing in some cases.

Thanks,
Jozef

> 
> > When I re-test I'll see if the errors pop up again.
> >
> > I still need to add the GNU OSABI handling, but with that and your
> > patches we are probably ready to apply after a final official sign-off.
> >
> > How would that work logistically, I apply my patch and you apply yours
> > after? Or do we align off-master and apply as one patch?
> >
> 
> Please get an account on gitlab.com and send me your account name.
> Then you can put your branch in
> 
> https://gitlab.com/x86-binutils/binutils-gdb
> 
> and we can work together to finish it.
> 
> 
> --
> H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[H.J. Lu]

On Thu, Sep 24, 2020 at 9:56 AM Jozef Lawrynowicz
<jozef.l@mittosystems.com> wrote:
>
> On Thu, Sep 24, 2020 at 06:59:07AM -0700, H.J. Lu via Binutils wrote:
> > On Thu, Sep 24, 2020 at 6:49 AM Jozef Lawrynowicz
> > <jozef.l@mittosystems.com> wrote:
> > >
> > > On Thu, Sep 24, 2020 at 06:18:05AM -0700, H.J. Lu via Binutils wrote:
> > > > On Wed, Sep 23, 2020 at 1:17 PM H.J. Lu <hjl.tools@gmail.com> wrote:
> > > > >
> > > > > On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
> > > > > <jozef.l@mittosystems.com> wrote:
> > > > > >
> > > > > > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > > > > > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > > >
> > > > > > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > > > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > > > > >
> > > > > > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > > > > > > Hello,
> > > > > > > > > > >
> > > > > > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > > > > > > >
> > > > > > > > > > > > > I think that:
> > > > > > > > > > > > >
> > > > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > >  foo:
> > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > >  .retain
> > > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > > >    ...
> > > > > > > > > > > > >
> > > > > > > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > > > > > > >
> > > > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > >  foo:
> > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > > >    ...
> > > > > > > > > > > > >
> > > > > > > > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > > > > > > > synonyms or short-hand for each other.
> > > > > > > > > > > > >
> > > > > > > > > > > >
> > > > > > > > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > > > > > > > right thing with
> > > > > > > > > > > >
> > > > > > > > > > > > .section .text,"ax"
> > > > > > > > > > > >    ...
> > > > > > > > > > > > foo:
> > > > > > > > > > > >   ...
> > > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > > >
> > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > >
> > > > > > > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > > > > > > >
> > > > > > > > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > > > > > > > either the whole section is retained or not.  What you describe is
> > > > > > > > > > > something else that would work on a per symbol basis, which would have to
> > > > > > > > > > > be specified in a different way and might or might not be a good idea.
> > > > > > > > > > > But let's not conflate these two.
> > > > > > > > > >
> > > > > > > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > > > > > > particular unused symbol anyway. Since garbage collection only operates
> > > > > > > > > > on the section level, marking the section itself as "retained" seems
> > > > > > > > > > most appropriate.
> > > > > > > > >
> > > > > > > > > It can be done.  If you put your branch on
> > > > > > > > >
> > > > > > > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > > > > > > >
> > > > > > > > > I can help you implement it.
> > > > > > > >
> > > > > > > > It's not something I have time to look into at the moment, for now the
> > > > > > > > aim is just to prevent garbage collection of sections.
> > > > > > >
> > > > > > > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> > > > > > > to the framework.  Check how SHF_GNU_MBIND works.
> > > > > >
> > > > > > Sorry, I don't understand.
> > > > > >
> > > > > > Are you saying that LD already supports the garbage collection of
> > > > > > individual unused symbol definitions from input sections? Whilst
> > > > > > retaining other symbol definitions which are required by the program?
> > > > > > I cannot find any reference to this.
> > > > > >
> > > > > > How does that relate to SHF_GNU_MBIND? I looked at all the references
> > > > > > to "mbind" in Binutils and nothing seemed related garbage collection of
> > > > > > sections, since SHF_GNU_MBIND is just used to indicate a particular
> > > > > > section should be placed in a special memory area.
> > > > >
> > > > > For
> > > > >
> > > > > section .text,"ax"
> > > > >    ...
> > > > > foo:
> > > > >   ...
> > > > >  .section .text,"axR"
> > > > > retained_fn:
> > > > >
> > > > > you need to create a new .text section with SHF_GNU_RETAIN for
> > > > > retained_fn.   See get_section in obj-elf.c.  If you want to avoid
> > > >
> > > > See users/hjl/elf/master branch at:
> > > >
> > > > https://gitlab.com/x86-binutils/binutils-gdb/-/commits/users/hjl/elf/master
> > > >
> > > > I removed the .retain directive.
> > >
> > > Thanks, the formalization of section flag merging in the assembler is
> > > nice.
> > >
> > > My only comment is that I used the "STT_*" syntax in the .type directive
> > > instead of % because some targets didn't like the % syntax and emmited
> > > an error. I don't remember which, maybe it was mmix-elf, in which case
> > > we don't care :)
> >
> > Some targets don't support @object.  %object works for all targets.
>
> Ah yes, it is in fact the non-existent mmix-elf that can't assemble
> %object but it works for all real targets.
>
> However, some targets don't support the .bss pseudo op which is used in
> your new tests, so those are failing in some cases.
>

Which ELF targets don't support .bss? gas/testsuite/gas/elf/bss.s has

.bss

Do they fail this test?

-- 
H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Thu, Sep 24, 2020 at 10:04:46AM -0700, H.J. Lu via Binutils wrote:
> On Thu, Sep 24, 2020 at 9:56 AM Jozef Lawrynowicz
> <jozef.l@mittosystems.com> wrote:
> >
> > On Thu, Sep 24, 2020 at 06:59:07AM -0700, H.J. Lu via Binutils wrote:
> > > On Thu, Sep 24, 2020 at 6:49 AM Jozef Lawrynowicz
> > > <jozef.l@mittosystems.com> wrote:
> > > >
> > > > On Thu, Sep 24, 2020 at 06:18:05AM -0700, H.J. Lu via Binutils wrote:
> > > > > On Wed, Sep 23, 2020 at 1:17 PM H.J. Lu <hjl.tools@gmail.com> wrote:
> > > > > >
> > > > > > On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
> > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > >
> > > > > > > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > > > > > > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > > > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > > > >
> > > > > > > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > > > > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > > > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > > > > > >
> > > > > > > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > > > > > > > Hello,
> > > > > > > > > > > >
> > > > > > > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > > > > > > > >
> > > > > > > > > > > > > > I think that:
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > >  foo:
> > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > >  .retain
> > > > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > >  foo:
> > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > > > > > > > > synonyms or short-hand for each other.
> > > > > > > > > > > > > >
> > > > > > > > > > > > >
> > > > > > > > > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > > > > > > > > right thing with
> > > > > > > > > > > > >
> > > > > > > > > > > > > .section .text,"ax"
> > > > > > > > > > > > >    ...
> > > > > > > > > > > > > foo:
> > > > > > > > > > > > >   ...
> > > > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > > > >
> > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > >
> > > > > > > > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > > > > > > > >
> > > > > > > > > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > > > > > > > > either the whole section is retained or not.  What you describe is
> > > > > > > > > > > > something else that would work on a per symbol basis, which would have to
> > > > > > > > > > > > be specified in a different way and might or might not be a good idea.
> > > > > > > > > > > > But let's not conflate these two.
> > > > > > > > > > >
> > > > > > > > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > > > > > > > particular unused symbol anyway. Since garbage collection only operates
> > > > > > > > > > > on the section level, marking the section itself as "retained" seems
> > > > > > > > > > > most appropriate.
> > > > > > > > > >
> > > > > > > > > > It can be done.  If you put your branch on
> > > > > > > > > >
> > > > > > > > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > > > > > > > >
> > > > > > > > > > I can help you implement it.
> > > > > > > > >
> > > > > > > > > It's not something I have time to look into at the moment, for now the
> > > > > > > > > aim is just to prevent garbage collection of sections.
> > > > > > > >
> > > > > > > > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> > > > > > > > to the framework.  Check how SHF_GNU_MBIND works.
> > > > > > >
> > > > > > > Sorry, I don't understand.
> > > > > > >
> > > > > > > Are you saying that LD already supports the garbage collection of
> > > > > > > individual unused symbol definitions from input sections? Whilst
> > > > > > > retaining other symbol definitions which are required by the program?
> > > > > > > I cannot find any reference to this.
> > > > > > >
> > > > > > > How does that relate to SHF_GNU_MBIND? I looked at all the references
> > > > > > > to "mbind" in Binutils and nothing seemed related garbage collection of
> > > > > > > sections, since SHF_GNU_MBIND is just used to indicate a particular
> > > > > > > section should be placed in a special memory area.
> > > > > >
> > > > > > For
> > > > > >
> > > > > > section .text,"ax"
> > > > > >    ...
> > > > > > foo:
> > > > > >   ...
> > > > > >  .section .text,"axR"
> > > > > > retained_fn:
> > > > > >
> > > > > > you need to create a new .text section with SHF_GNU_RETAIN for
> > > > > > retained_fn.   See get_section in obj-elf.c.  If you want to avoid
> > > > >
> > > > > See users/hjl/elf/master branch at:
> > > > >
> > > > > https://gitlab.com/x86-binutils/binutils-gdb/-/commits/users/hjl/elf/master
> > > > >
> > > > > I removed the .retain directive.
> > > >
> > > > Thanks, the formalization of section flag merging in the assembler is
> > > > nice.
> > > >
> > > > My only comment is that I used the "STT_*" syntax in the .type directive
> > > > instead of % because some targets didn't like the % syntax and emmited
> > > > an error. I don't remember which, maybe it was mmix-elf, in which case
> > > > we don't care :)
> > >
> > > Some targets don't support @object.  %object works for all targets.
> >
> > Ah yes, it is in fact the non-existent mmix-elf that can't assemble
> > %object but it works for all real targets.
> >
> > However, some targets don't support the .bss pseudo op which is used in
> > your new tests, so those are failing in some cases.
> >
> 
> Which ELF targets don't support .bss? gas/testsuite/gas/elf/bss.s has
> 
> .bss
> 
> Do they fail this test?

That test only runs for i?86-*-* x86_64-*-* ia64-*-* arm-*-* aarch64-*-*

The .bss directive causes an error for the following targets:
  arc-elf avr-elf cr16-elf cris-elf crx-elf d10v-elf d30v-elf dlx-elf
  epiphany-elf fr30-elf frv-elf ft32-elf h8300-elf ip2k-elf iq2000-elf
  lm32-elf m32r-elf m68hc11-elf m68hc12-elf mep-elf metag-elf mmix-elf
  mmix-elf moxie-elf msp430-elf mt-elf nios2-elf or1k-elf pj-elf ppc-elf
  pru-elf s12z-elf sh-elf sparc-elf tic6x-elf tilegx-elf tilepro-elf
  wasm32-elf xgate-elf xstormy16-elf xtensa-elf z80-elf

Thanks,
Jozef

> 
> -- 
> H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[H.J. Lu]

On Thu, Sep 24, 2020 at 10:18 AM Jozef Lawrynowicz
<jozef.l@mittosystems.com> wrote:
>
> On Thu, Sep 24, 2020 at 10:04:46AM -0700, H.J. Lu via Binutils wrote:
> > On Thu, Sep 24, 2020 at 9:56 AM Jozef Lawrynowicz
> > <jozef.l@mittosystems.com> wrote:
> > >
> > > On Thu, Sep 24, 2020 at 06:59:07AM -0700, H.J. Lu via Binutils wrote:
> > > > On Thu, Sep 24, 2020 at 6:49 AM Jozef Lawrynowicz
> > > > <jozef.l@mittosystems.com> wrote:
> > > > >
> > > > > On Thu, Sep 24, 2020 at 06:18:05AM -0700, H.J. Lu via Binutils wrote:
> > > > > > On Wed, Sep 23, 2020 at 1:17 PM H.J. Lu <hjl.tools@gmail.com> wrote:
> > > > > > >
> > > > > > > On Wed, Sep 23, 2020 at 1:04 PM Jozef Lawrynowicz
> > > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > > >
> > > > > > > > On Wed, Sep 23, 2020 at 12:03:28PM -0700, H.J. Lu via Binutils wrote:
> > > > > > > > > On Wed, Sep 23, 2020 at 11:47 AM Jozef Lawrynowicz
> > > > > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > > > > >
> > > > > > > > > > On Wed, Sep 23, 2020 at 10:13:37AM -0700, H.J. Lu via Binutils wrote:
> > > > > > > > > > > On Wed, Sep 23, 2020 at 9:52 AM Jozef Lawrynowicz
> > > > > > > > > > > <jozef.l@mittosystems.com> wrote:
> > > > > > > > > > > >
> > > > > > > > > > > > On Wed, Sep 23, 2020 at 01:51:56PM +0000, Michael Matz wrote:
> > > > > > > > > > > > > Hello,
> > > > > > > > > > > > >
> > > > > > > > > > > > > On Wed, 23 Sep 2020, H.J. Lu via Binutils wrote:
> > > > > > > > > > > > >
> > > > > > > > > > > > > > > I think that:
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > > >  foo:
> > > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > > >  .retain
> > > > > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > is some nice syntactic sugar compared to:
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > >  .section .text,"ax"
> > > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > > >  foo:
> > > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > It's also partly for convenience; we have other directives which are
> > > > > > > > > > > > > > > synonyms or short-hand for each other.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > You don't need to keep the whole section when only one symbol should
> > > > > > > > > > > > > > be kept.  Please drop the .retain directive.  GCC, as and ld should do the
> > > > > > > > > > > > > > right thing with
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > .section .text,"ax"
> > > > > > > > > > > > > >    ...
> > > > > > > > > > > > > > foo:
> > > > > > > > > > > > > >   ...
> > > > > > > > > > > > > >  .section .text,"axR"
> > > > > > > > > > > > > >
> > > > > > > > > > > > > >  retained_fn:
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > where foo can be dropped and retained_fn will be kept.
> > > > > > > > > > > > >
> > > > > > > > > > > > > This is not what we discussed at the ABI list, the flag is per section, so
> > > > > > > > > > > > > either the whole section is retained or not.  What you describe is
> > > > > > > > > > > > > something else that would work on a per symbol basis, which would have to
> > > > > > > > > > > > > be specified in a different way and might or might not be a good idea.
> > > > > > > > > > > > > But let's not conflate these two.
> > > > > > > > > > > >
> > > > > > > > > > > > Also, the linker cannot currently dissect a section and remove a
> > > > > > > > > > > > particular unused symbol anyway. Since garbage collection only operates
> > > > > > > > > > > > on the section level, marking the section itself as "retained" seems
> > > > > > > > > > > > most appropriate.
> > > > > > > > > > >
> > > > > > > > > > > It can be done.  If you put your branch on
> > > > > > > > > > >
> > > > > > > > > > > https://gitlab.com/x86-binutils/binutils-gdb
> > > > > > > > > > >
> > > > > > > > > > > I can help you implement it.
> > > > > > > > > >
> > > > > > > > > > It's not something I have time to look into at the moment, for now the
> > > > > > > > > > aim is just to prevent garbage collection of sections.
> > > > > > > > >
> > > > > > > > > Linker and assembler already support it.   You just need to add SHF_GNU_RETAIN
> > > > > > > > > to the framework.  Check how SHF_GNU_MBIND works.
> > > > > > > >
> > > > > > > > Sorry, I don't understand.
> > > > > > > >
> > > > > > > > Are you saying that LD already supports the garbage collection of
> > > > > > > > individual unused symbol definitions from input sections? Whilst
> > > > > > > > retaining other symbol definitions which are required by the program?
> > > > > > > > I cannot find any reference to this.
> > > > > > > >
> > > > > > > > How does that relate to SHF_GNU_MBIND? I looked at all the references
> > > > > > > > to "mbind" in Binutils and nothing seemed related garbage collection of
> > > > > > > > sections, since SHF_GNU_MBIND is just used to indicate a particular
> > > > > > > > section should be placed in a special memory area.
> > > > > > >
> > > > > > > For
> > > > > > >
> > > > > > > section .text,"ax"
> > > > > > >    ...
> > > > > > > foo:
> > > > > > >   ...
> > > > > > >  .section .text,"axR"
> > > > > > > retained_fn:
> > > > > > >
> > > > > > > you need to create a new .text section with SHF_GNU_RETAIN for
> > > > > > > retained_fn.   See get_section in obj-elf.c.  If you want to avoid
> > > > > >
> > > > > > See users/hjl/elf/master branch at:
> > > > > >
> > > > > > https://gitlab.com/x86-binutils/binutils-gdb/-/commits/users/hjl/elf/master
> > > > > >
> > > > > > I removed the .retain directive.
> > > > >
> > > > > Thanks, the formalization of section flag merging in the assembler is
> > > > > nice.
> > > > >
> > > > > My only comment is that I used the "STT_*" syntax in the .type directive
> > > > > instead of % because some targets didn't like the % syntax and emmited
> > > > > an error. I don't remember which, maybe it was mmix-elf, in which case
> > > > > we don't care :)
> > > >
> > > > Some targets don't support @object.  %object works for all targets.
> > >
> > > Ah yes, it is in fact the non-existent mmix-elf that can't assemble
> > > %object but it works for all real targets.
> > >
> > > However, some targets don't support the .bss pseudo op which is used in
> > > your new tests, so those are failing in some cases.
> > >
> >
> > Which ELF targets don't support .bss? gas/testsuite/gas/elf/bss.s has
> >
> > .bss
> >
> > Do they fail this test?
>
> That test only runs for i?86-*-* x86_64-*-* ia64-*-* arm-*-* aarch64-*-*
>
> The .bss directive causes an error for the following targets:
>   arc-elf avr-elf cr16-elf cris-elf crx-elf d10v-elf d30v-elf dlx-elf
>   epiphany-elf fr30-elf frv-elf ft32-elf h8300-elf ip2k-elf iq2000-elf
>   lm32-elf m32r-elf m68hc11-elf m68hc12-elf mep-elf metag-elf mmix-elf
>   mmix-elf moxie-elf msp430-elf mt-elf nios2-elf or1k-elf pj-elf ppc-elf
>   pru-elf s12z-elf sh-elf sparc-elf tic6x-elf tilegx-elf tilepro-elf
>   wasm32-elf xgate-elf xstormy16-elf xtensa-elf z80-elf
>

Fixed on users/hjl/elf/master branch.


-- 
H.J.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

[-- Attachment #1: Type: text/plain, Size: 3108 bytes --]

Attached a revised patch:
- Removed mmix-*-* XFAILs
- Fixed SHF_GNU_RETAIN being clobbered when using the .section directive
  without the "R" flag, after the section has previously been marked
  with SHF_GNU_RETAIN. Added tests for this behavior.

Thanks,
Jozef

On Tue, Sep 22, 2020 at 09:29:33PM +0100, Jozef Lawrynowicz wrote:
> The attached patch adds support for the new SHF_GNU_RETAIN ELF section
> flag, which was discussed on the GNU gABI mailing list here:
> https://sourceware.org/pipermail/gnu-gabi/2020q3/000429.html
> 
> The flag is GNU-specific so uses a bit in the SHF_MASKOS mask.
> Its precise definition is as follows:
> 
> =======================================================================
> Section Attribute Flags
> +-------------------------------------+
> | Name           | Value              |
> +-------------------------------------+
> | SHF_GNU_RETAIN | 0x200000 (1 << 21) |
> +-------------------------------------+
> 
> SHF_GNU_RETAIN
>   The link editor should not garbage collect the section if it is
>   unused.
> 
> =======================================================================
> 
> The overall intention for this new flag is to enable a new "retain"
> attribute to be applied to declarations of functions and data in the
> source code. This attribute can be used to ensure the definition
> associated with the declaration is present in the linked output file,
> even if linker garbage collection would normally remove the containing
> section because it is unused.
> 
> The new ".retain" assembler directive can be used to apply
> SHF_GNU_RETAIN to a section. GCC will emit this directive when
> assembling definitions of functions and data that have had the "retain"
> attribute applied.
> 
> Note that there is *not* a direct mapping of SHF_GNU_RETAIN to the BFD
> section flag SEC_KEEP. SEC_KEEP would prevent the user being able to
> explicitly remove an SHF_GNU_RETAIN section by placing it in /DISCARD/,
> which could be necessary in some situations.
> 
> I successfully regtested the patch for the Binutils, GAS and LD
> testsuites for the following CPUs, applying the "-elf" suffix when
> configuring:
>   aarch64 alpha arc arm avr bfin bpf cr16 cris crx csky d10v d30v dlx
>   epiphany fr30 frv ft32 h8300 hppa i386 ia64 ia64-vms ip2k iq2000 lm32
>   m32c m32r m68hc11 m68hc12 m68k mcore mep metag microblaze mips mmix
>   moxie msp430 mt nds32 nfp nios2 or1k pj ppc pru riscv rl78 rx s12z
>   s390 score sh sparc spu tic6x tilegx tilepro v850 vax visium wasm32
>   x86-64 x86 xc16x xgate xstormy16 xtensa z80
> 
> The new tests are passing for all targets except mmix-elf. This target
> has a lot of LD failures, particularly --gc-sections doesn't appear to
> have any effect. I don't know anything about the target, but I wonder if
> it should be added to the hard-coded list of targets that doesn't
> support --gc-sections.  I have therefore XFAIL'd the new LD tests for
> this target.
> 
> I also regtested for i386-pe, to ensure there was no spill-over of the
> new functionality into any non-ELF areas.
> 
> Ok to apply?
> 
> Thanks,
> Jozef

[-- Attachment #2: 0001-Support-SHF_GNU_RETAIN-ELF-section-flag.patch --]
[-- Type: text/plain, Size: 43996 bytes --]

From 862a04415e1b490b4561fe5a44c9fa4120c50825 Mon Sep 17 00:00:00 2001
From: Jozef Lawrynowicz <jozef.l@mittosystems.com>
Date: Tue, 22 Sep 2020 21:00:35 +0100
Subject: [PATCH] Support SHF_GNU_RETAIN ELF section flag

The GNU-specific SHF_GNU_RETAIN ELF section flag is defined as follows:

=======================================================================
Section Attribute Flags
+-------------------------------------+
| Name           | Value              |
+-------------------------------------+
| SHF_GNU_RETAIN | 0x200000 (1 << 21) |
+-------------------------------------+

SHF_GNU_RETAIN
  The link editor should not garbage collect the section if it is
  unused.

=======================================================================

The new ".retain" assembler directive can be used to apply
SHF_GNU_RETAIN to a section.

Note that there is not a direct mapping of SHF_GNU_RETAIN to the BFD
section flag SEC_KEEP. SEC_KEEP would prevent the user being able to
explicitly remove an SHF_GNU_RETAIN section by placing it in /DISCARD/.

bfd/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* elflink.c (bfd_elf_gc_sections): gc_mark the section if
	SHF_GNU_RETAIN is set.

binutils/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* NEWS: Announce SHF_GNU_RETAIN.
	* readelf.c (get_elf_section_flags): Handle SHF_GNU_RETAIN.
	* testsuite/binutils-all/readelf.exp: Run new test.
	Don't run run_dump_test when there isn't an assembler available.
	* testsuite/binutils-all/retain1.d: New test.
	* testsuite/binutils-all/retain1.s: New test.

gas/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* NEWS: Announce .retain directive and SHF_GNU_RETAIN.
	* config/obj-elf.c (elf_pseudo_table): Add "retain".
	(obj_elf_retain): New.
	(obj_elf_parse_section_letters): Handle 'R' flag.
	* doc/as.texi: Document .retain directive.
	(Section): Document 'R' flag.
	* testsuite/gas/elf/elf.exp: Run new tests.
	* testsuite/gas/elf/retain1.d: New test.
	* testsuite/gas/elf/retain1.s: New test.
	* testsuite/gas/elf/retain2.d: New test.
	* testsuite/gas/elf/retain2.l: New test.
	* testsuite/gas/elf/retain2.s: New test.
	* testsuite/gas/elf/retain3.d: New test.
	* testsuite/gas/elf/retain3.s: New test.
	* testsuite/gas/elf/section10.d: Adjust test.

include/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* elf/common.h (SHF_GNU_RETAIN): Define.

ld/ChangeLog:

2020-09-22  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* NEWS: Announce SHF_GNU_RETAIN.
	* ld.texi (garbage collection): Document SHF_GNU_RETAIN.
	(Output Section Discarding): Likewise.
	* testsuite/ld-elf/elf.exp: Run new tests.
	* testsuite/ld-elf/retain1.msg: New test.
	* testsuite/ld-elf/retain1.s: New test.
	* testsuite/ld-elf/retain2.d: New test.
	* testsuite/ld-elf/retain2.ld: New test.
	* testsuite/ld-elf/retain2.map: New test.
	* testsuite/ld-elf/retain3.msg: New test.
	* testsuite/ld-elf/retain3.s: New test.
	* testsuite/ld-elf/retain4.s: New test.
	* testsuite/ld-elf/retain5.s: New test.
	* testsuite/ld-elf/retain6lib.s: New test.
	* testsuite/ld-elf/retain6main.s: New test.
	* testsuite/ld-elf/retain7.msg: New test.
	* testsuite/ld-elf/retain7lib.s: New test.
	* testsuite/ld-elf/retain7main.s: New test.
---
 bfd/elflink.c                               |   3 +-
 binutils/NEWS                               |   4 +
 binutils/readelf.c                          |   4 +
 binutils/testsuite/binutils-all/readelf.exp |   6 +-
 binutils/testsuite/binutils-all/retain1.d   |  17 +++
 binutils/testsuite/binutils-all/retain1.s   | 114 ++++++++++++++++++++
 gas/NEWS                                    |   4 +
 gas/config/obj-elf.c                        |  71 +++++++++++-
 gas/doc/as.texi                             |  20 ++++
 gas/testsuite/gas/elf/elf.exp               |   7 ++
 gas/testsuite/gas/elf/retain1.d             |  24 +++++
 gas/testsuite/gas/elf/retain1.s             | 114 ++++++++++++++++++++
 gas/testsuite/gas/elf/retain2.d             |   3 +
 gas/testsuite/gas/elf/retain2.l             |   3 +
 gas/testsuite/gas/elf/retain2.s             |   7 ++
 gas/testsuite/gas/elf/retain3.d             |  24 +++++
 gas/testsuite/gas/elf/retain3.s             | 104 ++++++++++++++++++
 gas/testsuite/gas/elf/retain4.d             |   6 ++
 gas/testsuite/gas/elf/retain4.s             |  20 ++++
 gas/testsuite/gas/elf/retain5.d             |   6 ++
 gas/testsuite/gas/elf/retain5.s             |  18 ++++
 gas/testsuite/gas/elf/section10.d           |   4 +-
 include/elf/common.h                        |   1 +
 ld/NEWS                                     |   4 +
 ld/ld.texi                                  |   8 ++
 ld/testsuite/ld-elf/elf.exp                 |  33 ++++++
 ld/testsuite/ld-elf/retain1.msg             |   9 ++
 ld/testsuite/ld-elf/retain1.s               | 114 ++++++++++++++++++++
 ld/testsuite/ld-elf/retain2.d               |   6 ++
 ld/testsuite/ld-elf/retain2.ld              |   7 ++
 ld/testsuite/ld-elf/retain2.map             |  32 ++++++
 ld/testsuite/ld-elf/retain3.msg             |   9 ++
 ld/testsuite/ld-elf/retain3.s               | 104 ++++++++++++++++++
 ld/testsuite/ld-elf/retain4.s               |  19 ++++
 ld/testsuite/ld-elf/retain5.s               |  13 +++
 ld/testsuite/ld-elf/retain6lib.s            |   6 ++
 ld/testsuite/ld-elf/retain6main.s           |   5 +
 ld/testsuite/ld-elf/retain7.msg             |   1 +
 ld/testsuite/ld-elf/retain7lib.s            |  17 +++
 ld/testsuite/ld-elf/retain7main.s           |  13 +++
 40 files changed, 977 insertions(+), 7 deletions(-)
 create mode 100644 binutils/testsuite/binutils-all/retain1.d
 create mode 100644 binutils/testsuite/binutils-all/retain1.s
 create mode 100644 gas/testsuite/gas/elf/retain1.d
 create mode 100644 gas/testsuite/gas/elf/retain1.s
 create mode 100644 gas/testsuite/gas/elf/retain2.d
 create mode 100644 gas/testsuite/gas/elf/retain2.l
 create mode 100644 gas/testsuite/gas/elf/retain2.s
 create mode 100644 gas/testsuite/gas/elf/retain3.d
 create mode 100644 gas/testsuite/gas/elf/retain3.s
 create mode 100644 gas/testsuite/gas/elf/retain4.d
 create mode 100644 gas/testsuite/gas/elf/retain4.s
 create mode 100644 gas/testsuite/gas/elf/retain5.d
 create mode 100644 gas/testsuite/gas/elf/retain5.s
 create mode 100644 ld/testsuite/ld-elf/retain1.msg
 create mode 100644 ld/testsuite/ld-elf/retain1.s
 create mode 100644 ld/testsuite/ld-elf/retain2.d
 create mode 100644 ld/testsuite/ld-elf/retain2.ld
 create mode 100644 ld/testsuite/ld-elf/retain2.map
 create mode 100644 ld/testsuite/ld-elf/retain3.msg
 create mode 100644 ld/testsuite/ld-elf/retain3.s
 create mode 100644 ld/testsuite/ld-elf/retain4.s
 create mode 100644 ld/testsuite/ld-elf/retain5.s
 create mode 100644 ld/testsuite/ld-elf/retain6lib.s
 create mode 100644 ld/testsuite/ld-elf/retain6main.s
 create mode 100644 ld/testsuite/ld-elf/retain7.msg
 create mode 100644 ld/testsuite/ld-elf/retain7lib.s
 create mode 100644 ld/testsuite/ld-elf/retain7main.s

diff --git a/bfd/elflink.c b/bfd/elflink.c
index 0e339f3c1e..6d1a1c5105 100644
--- a/bfd/elflink.c
+++ b/bfd/elflink.c
@@ -13977,7 +13977,8 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
 			|| (elf_section_data (o)->this_hdr.sh_type
 			    == SHT_FINI_ARRAY)))
 		|| (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
-		    && elf_next_in_group (o) == NULL )))
+		    && elf_next_in_group (o) == NULL)
+		|| (elf_section_flags (o) & SHF_GNU_RETAIN)))
 	  {
 	    if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
 	      return FALSE;
diff --git a/binutils/NEWS b/binutils/NEWS
index c0dc73d7d8..6c7d3f3953 100644
--- a/binutils/NEWS
+++ b/binutils/NEWS
@@ -4,6 +4,10 @@
   symbol names.  In addition the --demangle=<style>, --no-demangle,
   --recurse-limit and --no-recurse-limit options are also now availale.
 
+* Add support for the SHF_GNU_RETAIN ELF section flag.
+  This flag specifies that the section should not be garbage collected by the
+  linker if it is unused.
+
 Changes in 2.35:
 
 * Changed readelf's display of symbol names when wide mode is not enabled.
diff --git a/binutils/readelf.c b/binutils/readelf.c
index cb4208f7b9..00502f7058 100644
--- a/binutils/readelf.c
+++ b/binutils/readelf.c
@@ -5977,6 +5977,8 @@ get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
       /* VLE specific.  */
       /* 25 */ { STRING_COMMA_LEN ("VLE") },
+      /* GNU specific.  */
+      /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
     };
 
   if (do_section_details)
@@ -6010,6 +6012,7 @@ get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
 	    case SHF_EXCLUDE:		sindex = 18; break;
 	    case SHF_COMPRESSED:	sindex = 20; break;
 	    case SHF_GNU_MBIND:		sindex = 24; break;
+	    case SHF_GNU_RETAIN:	sindex = 26; break;
 
 	    default:
 	      sindex = -1;
@@ -6108,6 +6111,7 @@ get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
 	    case SHF_EXCLUDE:		*p = 'E'; break;
 	    case SHF_COMPRESSED:	*p = 'C'; break;
 	    case SHF_GNU_MBIND:		*p = 'D'; break;
+	    case SHF_GNU_RETAIN:	*p = 'R'; break;
 
 	    default:
 	      if ((filedata->file_header.e_machine == EM_X86_64
diff --git a/binutils/testsuite/binutils-all/readelf.exp b/binutils/testsuite/binutils-all/readelf.exp
index 1fb36ae5c4..6dea09e305 100644
--- a/binutils/testsuite/binutils-all/readelf.exp
+++ b/binutils/testsuite/binutils-all/readelf.exp
@@ -364,8 +364,12 @@ readelf_wi_test
 readelf_compressed_wa_test
 
 readelf_dump_test
-run_dump_test "pr25543"
 
+# These dump tests require an assembler.
+if {[which $AS] != 0} then {
+    run_dump_test "pr25543"
+    run_dump_test "retain1"
+}
 
 # PR 13482 - Check for off-by-one errors when dumping .note sections.
 if {![binutils_assemble $srcdir/$subdir/version.s tmpdir/version.o]} then {
diff --git a/binutils/testsuite/binutils-all/retain1.d b/binutils/testsuite/binutils-all/retain1.d
new file mode 100644
index 0000000000..35d7373cc1
--- /dev/null
+++ b/binutils/testsuite/binutils-all/retain1.d
@@ -0,0 +1,17 @@
+#source: retain1.s
+#readelf: -S --wide
+#name: readelf SHF_GNU_RETAIN
+
+#...
+  \[[ 0-9]+\] .bss.retain0.*WAR.*
+  \[[ 0-9]+\] .bss.retain1.*WAR.*
+  \[[ 0-9]+\] .data.retain2.*WAR.*
+  \[[ 0-9]+\] .bss.sretain0.*WAR.*
+  \[[ 0-9]+\] .bss.sretain1.*WAR.*
+  \[[ 0-9]+\] .data.sretain2.*WAR.*
+  \[[ 0-9]+\] .text.fnretain1.*AXR.*
+#...
+  \[[ 0-9]+\] .bss.lsretain0.*WAR.*
+  \[[ 0-9]+\] .bss.lsretain1.*WAR.*
+  \[[ 0-9]+\] .data.lsretain2.*WAR.*
+#pass
diff --git a/binutils/testsuite/binutils-all/retain1.s b/binutils/testsuite/binutils-all/retain1.s
new file mode 100644
index 0000000000..e799ff72ec
--- /dev/null
+++ b/binutils/testsuite/binutils-all/retain1.s
@@ -0,0 +1,114 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"aw"
+	.type	retain0, STT_OBJECT
+	.retain	.bss.retain0
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"aw"
+	.type	retain1, STT_OBJECT
+	.retain	.bss.retain1
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"aw"
+	.type	retain2, STT_OBJECT
+	.retain	.data.retain2
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"aw"
+	.type	sretain0, STT_OBJECT
+	.retain	.bss.sretain0
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"aw"
+	.type	sretain1, STT_OBJECT
+	.retain	.bss.sretain1
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aw"
+	.type	sretain2, STT_OBJECT
+	.retain	.data.sretain2
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"ax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+	.retain	.text.fnretain1
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"aw"
+	.type	lsretain0.2, STT_OBJECT
+	.retain	.bss.lsretain0
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aw"
+	.type	lsretain1.1, STT_OBJECT
+	.retain	.bss.lsretain1
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aw"
+	.type	lsretain2.0, STT_OBJECT
+	.retain	.data.lsretain2
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/gas/NEWS b/gas/NEWS
index 66afd0357b..0d63fad7b3 100644
--- a/gas/NEWS
+++ b/gas/NEWS
@@ -9,6 +9,10 @@
 
 * Configure with --enable-x86-used-note by default for Linux/x86.
 
+* Add support for the .retain directive, which applies the ELF SHF_GNU_RETAIN
+  flag to the specified section.  This flag specifies the section should not be
+  garbage collected by the linker if it is unused.
+
 Changes in 2.35:
 
 * X86 NaCl target support is removed.
diff --git a/gas/config/obj-elf.c b/gas/config/obj-elf.c
index 9e39707801..5e384f2c58 100644
--- a/gas/config/obj-elf.c
+++ b/gas/config/obj-elf.c
@@ -78,6 +78,7 @@ static void obj_elf_gnu_attribute (int);
 static void obj_elf_tls_common (int);
 static void obj_elf_lcomm (int);
 static void obj_elf_struct (int);
+static void obj_elf_retain (int);
 
 static const pseudo_typeS elf_pseudo_table[] =
 {
@@ -119,6 +120,9 @@ static const pseudo_typeS elf_pseudo_table[] =
   /* A GNU extension for object attributes.  */
   {"gnu_attribute", obj_elf_gnu_attribute, 0},
 
+  /* A GNU extension for preventing linker garbage collection of sections.  */
+  {"retain", obj_elf_retain, 0},
+
   /* These are used for dwarf.  */
   {"2byte", cons, 2},
   {"4byte", cons, 4},
@@ -802,9 +806,15 @@ obj_elf_change_section (const char *name,
 		as_bad (_("changed section attributes for %s"), name);
 	    }
 	  else
-	    /* FIXME: Maybe we should consider removing a previously set
-	       processor or application specific attribute as suspicious ?  */
-	    elf_section_flags (sec) = attr;
+	    {
+	      /* Don't clobber SHF_GNU_RETAIN if it has been previously set on
+		 the section.  */
+	      attr |= (elf_section_flags (sec) & SHF_GNU_RETAIN);
+
+	      /* FIXME: Maybe we should consider removing a previously set
+		 processor or application specific attribute as suspicious ?  */
+	      elf_section_flags (sec) = attr;
+	    }
 
 	  if ((flags & SEC_MERGE) && old_sec->entsize != (unsigned) entsize)
 	    as_bad (_("changed section entity size for %s"), name);
@@ -857,6 +867,9 @@ obj_elf_parse_section_letters (char *str, size_t len,
 	case 'd':
 	  *gnu_attr |= SHF_GNU_MBIND;
 	  break;
+	case 'R':
+	  *gnu_attr |= SHF_GNU_RETAIN;
+	  break;
 	case '?':
 	  *is_clone = TRUE;
 	  break;
@@ -1986,6 +1999,58 @@ obj_elf_gnu_attribute (int ignored ATTRIBUTE_UNUSED)
   obj_elf_vendor_attribute (OBJ_ATTR_GNU);
 }
 
+/* Parse a ".retain [name]" directive.
+   The SHF_GNU_RETAIN flag should be applied to the section named "name".
+   If "name" is omitted, apply the flag to the current section being
+   assembled.  */
+static void
+obj_elf_retain (int ignored ATTRIBUTE_UNUSED)
+{
+  const char *name;
+  symbolS *secsym;
+  asection *bfdsec;
+
+  SKIP_WHITESPACE ();
+  if (*input_line_pointer == '\n')
+    {
+      /* Handle the case when "name" isn't specified.  */
+      name = now_seg->name;
+      if (name == NULL)
+	{
+	  as_bad (_("\".retain\" directive not within a section"));
+	  ignore_rest_of_line ();
+	  return;
+	}
+    }
+  else
+    {
+      /* The "name" argument has been given, validate it.  */
+      name = obj_elf_section_name ();
+      secsym = symbol_find (name);
+      if (secsym == NULL)
+	{
+	  as_bad (_("section '%s' has not been declared"), name);
+	  ignore_rest_of_line ();
+	  return;
+	}
+      else if (secsym != NULL
+	       && !symbol_section_p (secsym))
+	{
+	  as_bad (_("'%s' is not a section name, expected "
+		    "\".retain [name]\""), name);
+	  ignore_rest_of_line ();
+	  return;
+	}
+    }
+  demand_empty_rest_of_line ();
+
+  bfdsec = bfd_get_section_by_name (stdoutput, name);
+  if (bfdsec != NULL)
+    elf_section_flags (bfdsec) |= SHF_GNU_RETAIN;
+  else
+    as_bad (_("Couldn't find BFD section for %s\n"), name);
+}
+
 void
 elf_obj_read_begin_hook (void)
 {
diff --git a/gas/doc/as.texi b/gas/doc/as.texi
index 112eaf810c..68afaa6aae 100644
--- a/gas/doc/as.texi
+++ b/gas/doc/as.texi
@@ -4468,6 +4468,7 @@ Some machine configurations provide additional directives.
 * Quad::                        @code{.quad @var{bignums}}
 * Reloc::			@code{.reloc @var{offset}, @var{reloc_name}[, @var{expression}]}
 * Rept::			@code{.rept @var{count}}
+* Retain::			@code{.retain [@var{name}]}
 * Sbttl::                       @code{.sbttl "@var{subheading}"}
 @ifset COFF
 * Scl::                         @code{.scl @var{class}}
@@ -6468,6 +6469,22 @@ is equivalent to assembling
 A count of zero is allowed, but nothing is generated.  Negative counts are not
 allowed and if encountered will be treated as if they were zero.
 
+@ifset ELF
+@node Retain
+@section @code{.retain [@var{name}]}
+
+@cindex @code{retain} directive
+@cindex SHF_GNU_RETAIN
+
+Apply the @code{SHF_GNU_RETAIN} flag to the section named @var{name}.
+If @var{name} is omitted, apply the flag to the current section being
+assembled.
+
+The @code{SHF_GNU_RETAIN} flag specifies that the section should not be
+garbage collected by the linker if it is unused.
+
+@end ifset
+
 @node Sbttl
 @section @code{.sbttl "@var{subheading}"}
 
@@ -6546,6 +6563,9 @@ ignored.  (For compatibility with the ELF version)
 section is not readable (meaningful for PE targets)
 @item 0-9
 single-digit power-of-two section alignment (GNU extension)
+@item R
+retained section (apply SHF_GNU_RETAIN to prevent linker garbage
+collection, GNU ELF extension)
 @end table
 
 If no flags are specified, the default flags depend upon the section name.  If
diff --git a/gas/testsuite/gas/elf/elf.exp b/gas/testsuite/gas/elf/elf.exp
index 8520421ba3..c0dfdf504f 100644
--- a/gas/testsuite/gas/elf/elf.exp
+++ b/gas/testsuite/gas/elf/elf.exp
@@ -307,6 +307,13 @@ if { [is_elf_format] } then {
 
     run_dump_test "strtab"
 
+    # Tests for the .retain directive/SHF_GNU_RETAIN.
+    run_dump_test "retain1"
+    run_dump_test "retain2"
+    run_dump_test "retain3"
+    run_dump_test "retain4"
+    run_dump_test "retain5"
+
     run_dump_test "bignums"
     run_dump_test "section-symbol-redef"
     
diff --git a/gas/testsuite/gas/elf/retain1.d b/gas/testsuite/gas/elf/retain1.d
new file mode 100644
index 0000000000..439a60ca21
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain1.d
@@ -0,0 +1,24 @@
+#readelf: -S --wide
+#name: SHF_GNU_RETAIN 1
+
+#...
+  \[..\] .bss.discard0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.discard1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .data.discard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.sdiscard0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.sdiscard1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .data.sdiscard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .text.fndiscard0[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  AX.*
+  \[..\] .bss.retain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.retain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.retain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.sretain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.sretain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.sretain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .text.fnretain1[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 AXR.*
+  \[..\] .text.fndiscard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  AX.*
+#...
+  \[..\] .bss.lsretain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.lsretain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.lsretain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+#pass
diff --git a/gas/testsuite/gas/elf/retain1.s b/gas/testsuite/gas/elf/retain1.s
new file mode 100644
index 0000000000..e799ff72ec
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain1.s
@@ -0,0 +1,114 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"aw"
+	.type	retain0, STT_OBJECT
+	.retain	.bss.retain0
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"aw"
+	.type	retain1, STT_OBJECT
+	.retain	.bss.retain1
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"aw"
+	.type	retain2, STT_OBJECT
+	.retain	.data.retain2
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"aw"
+	.type	sretain0, STT_OBJECT
+	.retain	.bss.sretain0
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"aw"
+	.type	sretain1, STT_OBJECT
+	.retain	.bss.sretain1
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aw"
+	.type	sretain2, STT_OBJECT
+	.retain	.data.sretain2
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"ax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+	.retain	.text.fnretain1
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"aw"
+	.type	lsretain0.2, STT_OBJECT
+	.retain	.bss.lsretain0
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aw"
+	.type	lsretain1.1, STT_OBJECT
+	.retain	.bss.lsretain1
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aw"
+	.type	lsretain2.0, STT_OBJECT
+	.retain	.data.lsretain2
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/gas/testsuite/gas/elf/retain2.d b/gas/testsuite/gas/elf/retain2.d
new file mode 100644
index 0000000000..ca58b250b6
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain2.d
@@ -0,0 +1,3 @@
+#name: SHF_GNU_RETAIN 2
+#error_output: retain2.l
+#skip: hppa-*-*
diff --git a/gas/testsuite/gas/elf/retain2.l b/gas/testsuite/gas/elf/retain2.l
new file mode 100644
index 0000000000..5a44012567
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain2.l
@@ -0,0 +1,3 @@
+[^:]*: Assembler messages:
+[^:]*:1: Error: section '.data.foo' has not been declared
+[^:]*:7: Error: 'myvar' is not a section name, expected ".retain \[name\]"
diff --git a/gas/testsuite/gas/elf/retain2.s b/gas/testsuite/gas/elf/retain2.s
new file mode 100644
index 0000000000..75eb26d7f7
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain2.s
@@ -0,0 +1,7 @@
+.retain ".data.foo"
+.section .data,"aw"
+.global myvar
+.type myvar, STT_OBJECT
+myvar:
+	.byte 2
+.retain "myvar"
diff --git a/gas/testsuite/gas/elf/retain3.d b/gas/testsuite/gas/elf/retain3.d
new file mode 100644
index 0000000000..2d5ca68086
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain3.d
@@ -0,0 +1,24 @@
+#readelf: -S --wide
+#name: SHF_GNU_RETAIN 3 (use flags set on .section directive)
+
+#...
+  \[..\] .bss.discard0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.discard1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .data.discard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.sdiscard0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .bss.sdiscard1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .data.sdiscard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  WA.*
+  \[..\] .text.fndiscard0[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  AX.*
+  \[..\] .bss.retain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.retain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.retain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.sretain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.sretain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.sretain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .text.fnretain1[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 AXR.*
+  \[..\] .text.fndiscard2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00  AX.*
+#...
+  \[..\] .bss.lsretain0[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .bss.lsretain1[ 	]+NOBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+  \[..\] .data.lsretain2[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 WAR.*
+#pass
diff --git a/gas/testsuite/gas/elf/retain3.s b/gas/testsuite/gas/elf/retain3.s
new file mode 100644
index 0000000000..065399ec6f
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain3.s
@@ -0,0 +1,104 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"awR"
+	.type	retain0, STT_OBJECT
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"awR"
+	.type	retain1, STT_OBJECT
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"awR"
+	.type	retain2, STT_OBJECT
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"awR"
+	.type	sretain0, STT_OBJECT
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"awR"
+	.type	sretain1, STT_OBJECT
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aRw"
+	.type	sretain2, STT_OBJECT
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"Rax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"awR"
+	.type	lsretain0.2, STT_OBJECT
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aRw"
+	.type	lsretain1.1, STT_OBJECT
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aRw"
+	.type	lsretain2.0, STT_OBJECT
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/gas/testsuite/gas/elf/retain4.d b/gas/testsuite/gas/elf/retain4.d
new file mode 100644
index 0000000000..eacad20635
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain4.d
@@ -0,0 +1,6 @@
+#readelf: -S --wide
+#name: SHF_GNU_RETAIN 4 (switch to SHF_GNU_RETAIN section without "R" flag)
+
+#...
+  \[..\] .text.foo[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 AXR.*
+#pass
diff --git a/gas/testsuite/gas/elf/retain4.s b/gas/testsuite/gas/elf/retain4.s
new file mode 100644
index 0000000000..48aeae2a11
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain4.s
@@ -0,0 +1,20 @@
+/* SHF_GNU_RETAIN should not be clobbered when switching to a section without
+   explicitly specifying the flag.  */
+	.section	.text.foo,"axR"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.word 0
+
+	.section	.text.foo,"ax"
+	.global	bar
+	.type	bar, STT_FUNC
+bar:
+	.word 0
+
+	.section	.text.main,"ax"
+	.global	main
+	.type	main, STT_FUNC
+main:
+	.word 0
+
diff --git a/gas/testsuite/gas/elf/retain5.d b/gas/testsuite/gas/elf/retain5.d
new file mode 100644
index 0000000000..9edbfad710
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain5.d
@@ -0,0 +1,6 @@
+#readelf: -S --wide
+#name: SHF_GNU_RETAIN 5 (apply "R" flag to existing section)
+
+#...
+  \[..\] .text.foo[ 	]+PROGBITS[ 	]+[0-9a-f]+ [0-9a-f]+ [0-9a-f]+ 00 AXR.*
+#pass
diff --git a/gas/testsuite/gas/elf/retain5.s b/gas/testsuite/gas/elf/retain5.s
new file mode 100644
index 0000000000..c2957a7db4
--- /dev/null
+++ b/gas/testsuite/gas/elf/retain5.s
@@ -0,0 +1,18 @@
+/* Applying the "R" flag to an existing section should apply SHF_GNU_RETAIN.  */
+	.section	.text.foo,"ax"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.word 0
+
+	.section	.text.foo,"axR"
+	.global	bar
+	.type	bar, STT_FUNC
+bar:
+	.word 0
+
+	.section	.text.main,"ax"
+	.global	main
+	.type	main, STT_FUNC
+main:
+	.word 0
diff --git a/gas/testsuite/gas/elf/section10.d b/gas/testsuite/gas/elf/section10.d
index 554a791f1d..ef91d7d086 100644
--- a/gas/testsuite/gas/elf/section10.d
+++ b/gas/testsuite/gas/elf/section10.d
@@ -18,7 +18,7 @@
 #...
 [ 	]*\[.*\][ 	]+sec3
 [ 	]*PROGBITS.*
-[ 	]*\[.*fefff030\]: MERGE, STRINGS,.* EXCLUDE, OS \(.*ef00000\), PROC \(.*[3467]0000000\), UNKNOWN \(0+0ff000\)
+[ 	]*\[.*fefff030\]: MERGE, STRINGS,.* EXCLUDE, OS \(.*ed00000\), PROC \(.*[3467]0000000\), UNKNOWN \(0+0ff000\)
 #...
 [ 	]*\[.*\][ 	]+sec4
 [ 	]*LOOS\+0x11[ 	].*
@@ -26,7 +26,7 @@
 #...
 [ 	]*\[.*\][ 	]+sec5
 [ 	]*LOUSER\+0x9[ 	].*
-[ 	]*\[.*feff0000\]:.* EXCLUDE, OS \(.*ef00000\), PROC \(.*[3467]0000000\), UNKNOWN \(.*f0000\)
+[ 	]*\[.*feff0000\]:.* EXCLUDE, OS \(.*ed00000\), PROC \(.*[3467]0000000\), UNKNOWN \(.*f0000\)
 [ 	]*\[.*\][ 	]+.data.foo
 [ 	]*LOUSER\+0x7f000000[ 	].*
 [ 	]*\[0+003\]: WRITE, ALLOC
diff --git a/include/elf/common.h b/include/elf/common.h
index 805058146a..364c58a7de 100644
--- a/include/elf/common.h
+++ b/include/elf/common.h
@@ -554,6 +554,7 @@
 /* #define SHF_MASKOS	0x0F000000    *//* OS-specific semantics */
 #define SHF_MASKOS	0x0FF00000	/* New value, Oct 4, 1999 Draft */
 #define SHF_GNU_BUILD_NOTE    (1 << 20)	/* Section contains GNU BUILD ATTRIBUTE notes.  */
+#define SHF_GNU_RETAIN	      (1 << 21)	/* Section should not be garbage collected by the linker.  */
 #define SHF_MASKPROC	0xF0000000	/* Processor-specific semantics */
 
 /* This used to be implemented as a processor specific section flag.
diff --git a/ld/NEWS b/ld/NEWS
index 695348141b..1c3cc9d20a 100644
--- a/ld/NEWS
+++ b/ld/NEWS
@@ -13,6 +13,10 @@
   unless you are working on a project that has its own analogue
   of symbol tables that are not reflected in the ELF symtabs.
 
+* Add support for the SHF_GNU_RETAIN ELF section flag.
+  This flag specifies that the section should not be garbage collected by the
+  linker if it is unused.
+
 Changes in 2.35:
 
 * X86 NaCl target support is removed.
diff --git a/ld/ld.texi b/ld/ld.texi
index 7d961c3bb8..5daffbeb5f 100644
--- a/ld/ld.texi
+++ b/ld/ld.texi
@@ -1781,6 +1781,10 @@ specified either by one of the options @samp{--entry},
 @samp{--undefined}, or @samp{--gc-keep-exported} or by a @code{ENTRY}
 command in the linker script.
 
+As a GNU extension, ELF input sections marked with the
+@code{SHF_GNU_RETAIN} flag will not be garbage collected if they are
+unused.
+
 @kindex --print-gc-sections
 @kindex --no-print-gc-sections
 @cindex garbage collection
@@ -5226,6 +5230,10 @@ The special output section name @samp{/DISCARD/} may be used to discard
 input sections.  Any input sections which are assigned to an output
 section named @samp{/DISCARD/} are not included in the output file.
 
+This can be used to discard input sections marked with the ELF flag
+@code{SHF_GNU_RETAIN}, which would otherwise have been saved from linker
+garbage collection when they are unused.
+
 Note, sections that match the @samp{/DISCARD/} output section will be
 discarded even if they are in an ELF section group which has other
 members which are not being discarded.  This is deliberate.
diff --git a/ld/testsuite/ld-elf/elf.exp b/ld/testsuite/ld-elf/elf.exp
index c0d67d80d2..9046bc870a 100644
--- a/ld/testsuite/ld-elf/elf.exp
+++ b/ld/testsuite/ld-elf/elf.exp
@@ -225,6 +225,39 @@ if [check_gc_sections_available] {
 	    {pr25490-6.s} \
 	    [list [list "readelf" {-SW} $pr25490_6_exp]] \
 	    "pr25490-6.exe"] \
+	[list "SHF_GNU_RETAIN 1" \
+	    "--gc-sections -e _start --print-gc-sections" "" "" \
+	    {retain1.s} \
+	    {{ ld retain1.msg }} \
+	    "retain1.exe"] \
+	[list "SHF_GNU_RETAIN 3 (use flags set on .section directive)" \
+	    "--gc-sections -e _start --print-gc-sections" "" "" \
+	    {retain3.s} \
+	    {{ ld retain3.msg }} \
+	    "retain3.exe"] \
+	[list "SHF_GNU_RETAIN 4 (keep sections referenced by retained sections)" \
+	    "--gc-sections -e _start --print-gc-sections" "" "" \
+	    {retain4.s} {} \
+	    "retain4.exe"] \
+	[list "SHF_GNU_RETAIN 5 (keep orphaned sections when not discarding)" \
+	    "--gc-sections -e _start --print-gc-sections --orphan-handling=place" "" "" \
+	    {retain5.s} {} \
+	    "retain5.exe"] \
+	[list "Build libretain6.a" \
+	    "" "" "" \
+	    {retain6lib.s} {} "libretain6.a"] \
+	[list "SHF_GNU_RETAIN 6 (don't pull SHF_GNU_RETAIN section out of lib)" \
+	    "--gc-sections -e _start --print-gc-sections" "-Ltmpdir -lretain6" "" \
+	    {retain6main.s} {} \
+	    "retain6.exe"] \
+	[list "Build libretain7.a" \
+	    "" "" "" \
+	    {retain7lib.s} {} "libretain7.a"] \
+	[list "SHF_GNU_RETAIN 7 (pull section out of lib required by SHF_GNU_RETAIN section)" \
+	    "--gc-sections -e _start --print-gc-sections" "-Ltmpdir -lretain7" "" \
+	    {retain7main.s} \
+	    {{ ld retain7.msg }} \
+	    "retain7.exe"] \
 	]
 }
 
diff --git a/ld/testsuite/ld-elf/retain1.msg b/ld/testsuite/ld-elf/retain1.msg
new file mode 100644
index 0000000000..9a265c980f
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain1.msg
@@ -0,0 +1,9 @@
+.*: removing unused section '.bss.discard0' in file.*
+.*: removing unused section '.bss.discard1' in file.*
+.*: removing unused section '.data.discard2' in file.*
+.*: removing unused section '.bss.sdiscard0' in file.*
+.*: removing unused section '.bss.sdiscard1' in file.*
+.*: removing unused section '.data.sdiscard2' in file.*
+.*: removing unused section '.text.fndiscard0' in file.*
+.*: removing unused section '.text.fndiscard2' in file.*
+#pass
diff --git a/ld/testsuite/ld-elf/retain1.s b/ld/testsuite/ld-elf/retain1.s
new file mode 100644
index 0000000000..e799ff72ec
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain1.s
@@ -0,0 +1,114 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"aw"
+	.type	retain0, STT_OBJECT
+	.retain	.bss.retain0
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"aw"
+	.type	retain1, STT_OBJECT
+	.retain	.bss.retain1
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"aw"
+	.type	retain2, STT_OBJECT
+	.retain	.data.retain2
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"aw"
+	.type	sretain0, STT_OBJECT
+	.retain	.bss.sretain0
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"aw"
+	.type	sretain1, STT_OBJECT
+	.retain	.bss.sretain1
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aw"
+	.type	sretain2, STT_OBJECT
+	.retain	.data.sretain2
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"ax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+	.retain	.text.fnretain1
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"aw"
+	.type	lsretain0.2, STT_OBJECT
+	.retain	.bss.lsretain0
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aw"
+	.type	lsretain1.1, STT_OBJECT
+	.retain	.bss.lsretain1
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aw"
+	.type	lsretain2.0, STT_OBJECT
+	.retain	.data.lsretain2
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain2.d b/ld/testsuite/ld-elf/retain2.d
new file mode 100644
index 0000000000..9834d58297
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain2.d
@@ -0,0 +1,6 @@
+# Test that sections marked with SHF_GNU_RETAIN can be removed by placing them
+# in /DISCARD/.
+# source: retain1.s
+# ld: -e _start -Map=retain2.map --gc-sections --script=retain2.ld
+# map: retain2.map
+# skip: mep-*-* dlx-*-* d30v-*-* pj-*-* pru-*-* xgate-*-* s12z-*-*
diff --git a/ld/testsuite/ld-elf/retain2.ld b/ld/testsuite/ld-elf/retain2.ld
new file mode 100644
index 0000000000..8ef982753c
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain2.ld
@@ -0,0 +1,7 @@
+SECTIONS
+{
+  /DISCARD/ :
+  {
+    *(.text.fnretain1)
+  }
+}
diff --git a/ld/testsuite/ld-elf/retain2.map b/ld/testsuite/ld-elf/retain2.map
new file mode 100644
index 0000000000..4028aa1f58
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain2.map
@@ -0,0 +1,32 @@
+# Test that .text.fnretain1, which has the SHF_GNU_RETAIN flag, can still be
+# explicitly discarded from the output file.
+
+#...
+Discarded input sections
+
+ .text.*
+#...
+ .data.*
+#...
+ .bss.*
+#...
+ .bss.discard0.*
+#...
+ .bss.discard1.*
+#...
+ .data.discard2.*
+#...
+ .bss.sdiscard0.*
+#...
+ .bss.sdiscard1.*
+#...
+ .data.sdiscard2.*
+#...
+ .text.fndiscard0.*
+#...
+ .text.fnretain1.*
+#...
+ .text.fndiscard2.*
+#...
+Memory Configuration
+#pass
diff --git a/ld/testsuite/ld-elf/retain3.msg b/ld/testsuite/ld-elf/retain3.msg
new file mode 100644
index 0000000000..9a265c980f
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain3.msg
@@ -0,0 +1,9 @@
+.*: removing unused section '.bss.discard0' in file.*
+.*: removing unused section '.bss.discard1' in file.*
+.*: removing unused section '.data.discard2' in file.*
+.*: removing unused section '.bss.sdiscard0' in file.*
+.*: removing unused section '.bss.sdiscard1' in file.*
+.*: removing unused section '.data.sdiscard2' in file.*
+.*: removing unused section '.text.fndiscard0' in file.*
+.*: removing unused section '.text.fndiscard2' in file.*
+#pass
diff --git a/ld/testsuite/ld-elf/retain3.s b/ld/testsuite/ld-elf/retain3.s
new file mode 100644
index 0000000000..065399ec6f
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain3.s
@@ -0,0 +1,104 @@
+	.global	discard0
+	.section	.bss.discard0,"aw"
+	.type	discard0, STT_OBJECT
+discard0:
+	.zero	2
+
+	.global	discard1
+	.section	.bss.discard1,"aw"
+	.type	discard1, STT_OBJECT
+discard1:
+	.zero	2
+
+	.global	discard2
+	.section	.data.discard2,"aw"
+	.type	discard2, STT_OBJECT
+discard2:
+	.word	1
+
+	.section	.bss.sdiscard0,"aw"
+	.type	sdiscard0, STT_OBJECT
+sdiscard0:
+	.zero	2
+
+	.section	.bss.sdiscard1,"aw"
+	.type	sdiscard1, STT_OBJECT
+sdiscard1:
+	.zero	2
+
+	.section	.data.sdiscard2,"aw"
+	.type	sdiscard2, STT_OBJECT
+sdiscard2:
+	.word	1
+
+	.section	.text.fndiscard0,"ax"
+	.global	fndiscard0
+	.type	fndiscard0, STT_FUNC
+fndiscard0:
+	.word 0
+
+	.global	retain0
+	.section	.bss.retain0,"awR"
+	.type	retain0, STT_OBJECT
+retain0:
+	.zero	2
+
+	.global	retain1
+	.section	.bss.retain1,"awR"
+	.type	retain1, STT_OBJECT
+retain1:
+	.zero	2
+
+	.global	retain2
+	.section	.data.retain2,"awR"
+	.type	retain2, STT_OBJECT
+retain2:
+	.word	1
+
+	.section	.bss.sretain0,"awR"
+	.type	sretain0, STT_OBJECT
+sretain0:
+	.zero	2
+
+	.section	.bss.sretain1,"awR"
+	.type	sretain1, STT_OBJECT
+sretain1:
+	.zero	2
+
+	.section	.data.sretain2,"aRw"
+	.type	sretain2, STT_OBJECT
+sretain2:
+	.word	1
+
+	.section	.text.fnretain1,"Rax"
+	.global	fnretain1
+	.type	fnretain1, STT_FUNC
+fnretain1:
+	.word	0
+
+	.section	.text.fndiscard2,"ax"
+	.global	fndiscard2
+	.type	fndiscard2, STT_FUNC
+fndiscard2:
+	.word	0
+
+	.section	.bss.lsretain0,"awR"
+	.type	lsretain0.2, STT_OBJECT
+lsretain0.2:
+	.zero	2
+
+	.section	.bss.lsretain1,"aRw"
+	.type	lsretain1.1, STT_OBJECT
+lsretain1.1:
+	.zero	2
+
+	.section	.data.lsretain2,"aRw"
+	.type	lsretain2.0, STT_OBJECT
+lsretain2.0:
+	.word	1
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain4.s b/ld/testsuite/ld-elf/retain4.s
new file mode 100644
index 0000000000..080a5dfc2e
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain4.s
@@ -0,0 +1,19 @@
+/* The retention of bar should also prevent foo from being gc'ed, since bar
+   references foo.  */
+	.section	.text.foo,"ax"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.word 0
+
+	.section	.text.bar,"axR"
+	.global	bar
+	.type	bar, STT_FUNC
+bar:
+	.long foo
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain5.s b/ld/testsuite/ld-elf/retain5.s
new file mode 100644
index 0000000000..5ffadad694
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain5.s
@@ -0,0 +1,13 @@
+/* A section which doesn't match any linker script input section rules but
+   has SHF_GNU_RETAIN applied should not be garbage collected.  */
+	.section	.orphaned_section,"axR"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.word 0
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain6lib.s b/ld/testsuite/ld-elf/retain6lib.s
new file mode 100644
index 0000000000..4de7adea3d
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain6lib.s
@@ -0,0 +1,6 @@
+/* The link will fail if foo is included because undefined_sym is not defined.  */
+	.section	.text.foo,"axR"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.long undefined_sym
diff --git a/ld/testsuite/ld-elf/retain6main.s b/ld/testsuite/ld-elf/retain6main.s
new file mode 100644
index 0000000000..7c722481e8
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain6main.s
@@ -0,0 +1,5 @@
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain7.msg b/ld/testsuite/ld-elf/retain7.msg
new file mode 100644
index 0000000000..c21e3b9d75
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain7.msg
@@ -0,0 +1 @@
+.*: removing unused section '.text.discard_from_lib' in file.*
diff --git a/ld/testsuite/ld-elf/retain7lib.s b/ld/testsuite/ld-elf/retain7lib.s
new file mode 100644
index 0000000000..2aebf32bd0
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain7lib.s
@@ -0,0 +1,17 @@
+	.section	.text.bar,"ax"
+	.global	bar
+	.type	bar, STT_FUNC
+bar:
+	.word 0
+
+	.section	.text.retain_from_lib,"axR"
+	.global	retain_from_lib
+	.type	retain_from_lib, STT_FUNC
+retain_from_lib:
+	.word 0
+
+	.section	.text.discard_from_lib,"ax"
+	.global	discard_from_lib
+	.type	discard_from_lib, STT_FUNC
+discard_from_lib:
+	.word 0
diff --git a/ld/testsuite/ld-elf/retain7main.s b/ld/testsuite/ld-elf/retain7main.s
new file mode 100644
index 0000000000..d8ce70e718
--- /dev/null
+++ b/ld/testsuite/ld-elf/retain7main.s
@@ -0,0 +1,13 @@
+/* Undefined symbol reference in retained section .text.foo requires symbol
+   definition to be pulled out of library.  */
+	.section	.text.foo,"axR"
+	.global	foo
+	.type	foo, STT_FUNC
+foo:
+	.long bar
+
+	.section	.text._start,"ax"
+	.global	_start
+	.type	_start, STT_FUNC
+_start:
+	.word 0
-- 
2.28.0

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Alan Modra]

On Wed, Sep 23, 2020 at 01:13:48PM +0100, Jozef Lawrynowicz wrote:
> Attached a revised patch:
> - Removed mmix-*-* XFAILs
> - Fixed SHF_GNU_RETAIN being clobbered when using the .section directive
>   without the "R" flag, after the section has previously been marked
>   with SHF_GNU_RETAIN. Added tests for this behavior.

In my quick scan over your patch, I didn't see anything that would set
ELFOSABI_GNU.  Since SHF_GNU_RETAIN is in the SHF_MASKOS range,
generating sections with the flag set should also set OSABI, and
if an object has the wrong OSABI you can't interpret that bit as
SHF_GNU_RETAIN.  See has_gnu_osabi for the way this is handled in
bfd.

-- 
Alan Modra
Australia Development Lab, IBM

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Wed, Sep 23, 2020 at 11:29:05PM +0930, Alan Modra via Binutils wrote:
> On Wed, Sep 23, 2020 at 01:13:48PM +0100, Jozef Lawrynowicz wrote:
> > Attached a revised patch:
> > - Removed mmix-*-* XFAILs
> > - Fixed SHF_GNU_RETAIN being clobbered when using the .section directive
> >   without the "R" flag, after the section has previously been marked
> >   with SHF_GNU_RETAIN. Added tests for this behavior.
> 
> In my quick scan over your patch, I didn't see anything that would set
> ELFOSABI_GNU.  Since SHF_GNU_RETAIN is in the SHF_MASKOS range,
> generating sections with the flag set should also set OSABI, and
> if an object has the wrong OSABI you can't interpret that bit as
> SHF_GNU_RETAIN.  See has_gnu_osabi for the way this is handled in
> bfd.

Ah yes, I'll fix that.

Thanks,
Jozef

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Pedro Alves]

On 9/22/20 9:29 PM, Jozef Lawrynowicz wrote:
> 
> The overall intention for this new flag is to enable a new "retain"
> attribute to be applied to declarations of functions and data in the
> source code. This attribute can be used to ensure the definition
> associated with the declaration is present in the linked output file,
> even if linker garbage collection would normally remove the containing
> section because it is unused.

On a high level, this sounds pretty much like __attribute__((used)).
Couldn't the new section flag be wired to that attribute?  

I mean, isn't it a bug if linker garbage collection eliminates a
function marked with __attribute__((used)) ?

 "used

   This attribute, attached to a function, means that code must be emitted 
   for the function even if it appears that the function is not referenced."

I was surprised to not see any mention of the "used" attribute in the
proposal, neither here, nor in gABI mailing list discussion linked.
But maybe I missed it.

Pedro Alves

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Mon, Sep 28, 2020 at 12:35:28PM +0100, Pedro Alves wrote:
> On 9/22/20 9:29 PM, Jozef Lawrynowicz wrote:
> > 
> > The overall intention for this new flag is to enable a new "retain"
> > attribute to be applied to declarations of functions and data in the
> > source code. This attribute can be used to ensure the definition
> > associated with the declaration is present in the linked output file,
> > even if linker garbage collection would normally remove the containing
> > section because it is unused.
> 
> On a high level, this sounds pretty much like __attribute__((used)).
> Couldn't the new section flag be wired to that attribute?  
> 
> I mean, isn't it a bug if linker garbage collection eliminates a
> function marked with __attribute__((used)) ?
> 
>  "used
> 
>    This attribute, attached to a function, means that code must be emitted 
>    for the function even if it appears that the function is not referenced."
> 
> I was surprised to not see any mention of the "used" attribute in the
> proposal, neither here, nor in gABI mailing list discussion linked.
> But maybe I missed it.

In an early version of the implementation, I tried tying the
behavior to the "used" attribute, but it caused some problems.

I believe the issues mainly came from the usage of "used" in
libgcc/crtstuff.c. The functions there are static and unused, so have
"used" applied to prevent removal by the compiler. However, that does
not mean that all of those functions should be included in every program
linking against libgcc.

I don't remember the exact failure mode, I think it may have been that
lots of tests were failing due to "multiple definition of ..." errors,
or perhaps "undefined reference to ...".

The "retain" attribute implies the "used" attribute, so if the user
wants to prevent compiler optimization AND linker optimization, "retain"
can be used. To prevent only compiler optimization, "used" should be
applied.

Jozef
> 
> Pedro Alves

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Pedro Alves]

On 9/28/20 1:28 PM, Jozef Lawrynowicz wrote:
> On Mon, Sep 28, 2020 at 12:35:28PM +0100, Pedro Alves wrote:
>> On 9/22/20 9:29 PM, Jozef Lawrynowicz wrote:
>>>
>>> The overall intention for this new flag is to enable a new "retain"
>>> attribute to be applied to declarations of functions and data in the
>>> source code. This attribute can be used to ensure the definition
>>> associated with the declaration is present in the linked output file,
>>> even if linker garbage collection would normally remove the containing
>>> section because it is unused.
>>
>> On a high level, this sounds pretty much like __attribute__((used)).
>> Couldn't the new section flag be wired to that attribute?  
>>
>> I mean, isn't it a bug if linker garbage collection eliminates a
>> function marked with __attribute__((used)) ?
>>
>>  "used
>>
>>    This attribute, attached to a function, means that code must be emitted 
>>    for the function even if it appears that the function is not referenced."
>>
>> I was surprised to not see any mention of the "used" attribute in the
>> proposal, neither here, nor in gABI mailing list discussion linked.
>> But maybe I missed it.
> 
> In an early version of the implementation, I tried tying the
> behavior to the "used" attribute, but it caused some problems.
> 
> I believe the issues mainly came from the usage of "used" in
> libgcc/crtstuff.c. The functions there are static and unused, so have
> "used" applied to prevent removal by the compiler. However, that does
> not mean that all of those functions should be included in every program
> linking against libgcc.
> 
> I don't remember the exact failure mode, I think it may have been that
> lots of tests were failing due to "multiple definition of ..." errors,
> or perhaps "undefined reference to ...".

That's really strange, and to be honest, not very convincing.

If there are multiple static functions with the same name in the same
translation unit, when you should be getting errors at compile time.

If OTOH, your early implementation resulted in undefined references,
then it just sounds like a bug in your implementation, since as you say,
__attribute__((retain)) is a superset of __attribute__((used)).  As in,
undefined references suggests the function wasn't emitted, contrary to
the point of the attribute.

> 
> The "retain" attribute implies the "used" attribute, so if the user
> wants to prevent compiler optimization AND linker optimization, "retain"
> can be used. To prevent only compiler optimization, "used" should be
> applied.

I'm not convinced such a distinction makes sense.  Maybe a small self
contained use case where the distinction makes a difference and is
desirable would help.

Pedro Alves

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Michael Matz]

Hello,

On Mon, 28 Sep 2020, Pedro Alves wrote:

> >>> The overall intention for this new flag is to enable a new "retain"
> >>> attribute to be applied to declarations of functions and data in the
> >>> source code. This attribute can be used to ensure the definition
> >>> associated with the declaration is present in the linked output file,
> >>> even if linker garbage collection would normally remove the containing
> >>> section because it is unused.
> >>
> >> On a high level, this sounds pretty much like __attribute__((used)).
> >> Couldn't the new section flag be wired to that attribute?  
> >>
> >> I mean, isn't it a bug if linker garbage collection eliminates a
> >> function marked with __attribute__((used)) ?
> >>
> >>  "used
> >>
> >>    This attribute, attached to a function, means that code must be emitted 
> >>    for the function even if it appears that the function is not referenced."
> >>
> >> I was surprised to not see any mention of the "used" attribute in the
> >> proposal, neither here, nor in gABI mailing list discussion linked.
> >> But maybe I missed it.
> > 
> > In an early version of the implementation, I tried tying the
> > behavior to the "used" attribute, but it caused some problems.
> > 
> > I believe the issues mainly came from the usage of "used" in
> > libgcc/crtstuff.c. The functions there are static and unused, so have
> > "used" applied to prevent removal by the compiler. However, that does
> > not mean that all of those functions should be included in every program
> > linking against libgcc.
> > 
> > I don't remember the exact failure mode, I think it may have been that
> > lots of tests were failing due to "multiple definition of ..." errors,
> > or perhaps "undefined reference to ...".
> 
> That's really strange, and to be honest, not very convincing.
> 
> If there are multiple static functions with the same name in the same
> translation unit, when you should be getting errors at compile time.
> 
> If OTOH, your early implementation resulted in undefined references,
> then it just sounds like a bug in your implementation, since as you say,
> __attribute__((retain)) is a superset of __attribute__((used)).  As in,
> undefined references suggests the function wasn't emitted, contrary to
> the point of the attribute.
> 
> > 
> > The "retain" attribute implies the "used" attribute, so if the user
> > wants to prevent compiler optimization AND linker optimization, "retain"
> > can be used. To prevent only compiler optimization, "used" should be
> > applied.
> 
> I'm not convinced such a distinction makes sense.  Maybe a small self
> contained use case where the distinction makes a difference and is
> desirable would help.

We should remember that this thread is about the addition of the section 
flag, which affects but isn't directly related to how it's going to be 
used in source code in a high level language.  If it's the pre-existing 
"used" or a new "retain" attribute, or an attribute at all or just left to 
section markers or pragmas: a discussion about that doesn't need to hold 
up the addition of the ELF feature.


Ciao,
Michael.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Jozef Lawrynowicz]

On Tue, Sep 29, 2020 at 01:18:31PM +0000, Michael Matz wrote:
> Hello,
> 
> On Mon, 28 Sep 2020, Pedro Alves wrote:
> 
> > >>> The overall intention for this new flag is to enable a new "retain"
> > >>> attribute to be applied to declarations of functions and data in the
> > >>> source code. This attribute can be used to ensure the definition
> > >>> associated with the declaration is present in the linked output file,
> > >>> even if linker garbage collection would normally remove the containing
> > >>> section because it is unused.
> > >>
> > >> On a high level, this sounds pretty much like __attribute__((used)).
> > >> Couldn't the new section flag be wired to that attribute?  
> > >>
> > >> I mean, isn't it a bug if linker garbage collection eliminates a
> > >> function marked with __attribute__((used)) ?
> > >>
> > >>  "used
> > >>
> > >>    This attribute, attached to a function, means that code must be emitted 
> > >>    for the function even if it appears that the function is not referenced."
> > >>
> > >> I was surprised to not see any mention of the "used" attribute in the
> > >> proposal, neither here, nor in gABI mailing list discussion linked.
> > >> But maybe I missed it.
> > > 
> > > In an early version of the implementation, I tried tying the
> > > behavior to the "used" attribute, but it caused some problems.
> > > 
> > > I believe the issues mainly came from the usage of "used" in
> > > libgcc/crtstuff.c. The functions there are static and unused, so have
> > > "used" applied to prevent removal by the compiler. However, that does
> > > not mean that all of those functions should be included in every program
> > > linking against libgcc.
> > > 
> > > I don't remember the exact failure mode, I think it may have been that
> > > lots of tests were failing due to "multiple definition of ..." errors,
> > > or perhaps "undefined reference to ...".
> > 
> > That's really strange, and to be honest, not very convincing.
> > 
> > If there are multiple static functions with the same name in the same
> > translation unit, when you should be getting errors at compile time.
> > 
> > If OTOH, your early implementation resulted in undefined references,
> > then it just sounds like a bug in your implementation, since as you say,
> > __attribute__((retain)) is a superset of __attribute__((used)).  As in,
> > undefined references suggests the function wasn't emitted, contrary to
> > the point of the attribute.
> > 
> > > 
> > > The "retain" attribute implies the "used" attribute, so if the user
> > > wants to prevent compiler optimization AND linker optimization, "retain"
> > > can be used. To prevent only compiler optimization, "used" should be
> > > applied.
> > 
> > I'm not convinced such a distinction makes sense.  Maybe a small self
> > contained use case where the distinction makes a difference and is
> > desirable would help.
> 
> We should remember that this thread is about the addition of the section 
> flag, which affects but isn't directly related to how it's going to be 
> used in source code in a high level language.  If it's the pre-existing 
> "used" or a new "retain" attribute, or an attribute at all or just left to 
> section markers or pragmas: a discussion about that doesn't need to hold 
> up the addition of the ELF feature.

Yep, thanks Michael.

I'm working on the GCC implementation at the moment, I'll review what
happens if "used" implies SHF_GNU_RETAIN before I submit to gcc-patches,
and that aspect of the implementation can be discussed there.

Jozef

> 
> 
> Ciao,
> Michael.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Pedro Alves]

On 9/29/20 2:18 PM, Michael Matz wrote:

> We should remember that this thread is about the addition of the section 
> flag, which affects but isn't directly related to how it's going to be 
> used in source code in a high level language.  If it's the pre-existing 
> "used" or a new "retain" attribute, or an attribute at all or just left to 
> section markers or pragmas: a discussion about that doesn't need to hold 
> up the addition of the ELF feature.

I never suggested that it should (hold up the ELF feature).  I was
replying to this in the original message:

> The overall intention for this new flag is to enable a new "retain"
> attribute to be applied to declarations of functions and data in the
> source code. This attribute can be used to ensure the definition
> associated with the declaration is present in the linked output file,
> even if linker garbage collection would normally remove the containing
> section because it is unused.

Discussing the intention of a new proposed mechanism seems apropos.
Sometimes the high level usage model influences the low level design too.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Michael Matz]

Hello,

On Tue, 29 Sep 2020, Pedro Alves wrote:

> > We should remember that this thread is about the addition of the section 
> > flag, which affects but isn't directly related to how it's going to be 
> > used in source code in a high level language.  If it's the pre-existing 
> > "used" or a new "retain" attribute, or an attribute at all or just left to 
> > section markers or pragmas: a discussion about that doesn't need to hold 
> > up the addition of the ELF feature.
> 
> I never suggested that it should (hold up the ELF feature).

Okay.

> I was replying to this in the original message:
> 
> > The overall intention for this new flag is to enable a new "retain"
> > attribute to be applied to declarations of functions and data in the
> > source code. This attribute can be used to ensure the definition
> > associated with the declaration is present in the linked output file,
> > even if linker garbage collection would normally remove the containing
> > section because it is unused.
> 
> Discussing the intention of a new proposed mechanism seems apropos.
> Sometimes the high level usage model influences the low level design too.

Definitely.  But used vs retain attribute seemed like a too detailed 
distinction to make at this point.  For the GCC patches it's totally 
appropriate, though, as planned.


Ciao,
Michael.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Pedro Alves]

On 9/29/20 2:55 PM, Michael Matz wrote:

> Definitely.  But used vs retain attribute seemed like a too detailed 
> distinction to make at this point.  For the GCC patches it's totally 
> appropriate, though, as planned.

It's only planned now because I brought it up.  I think that shooting
down a subthread like this implying I'm getting in the way is kind of
uncalled for, to be honest.  If anything, it should make people wonder
whether a better name for the flag would be SHF_GNU_USED, so that we
don't end up with more than one term for the same thing in the
toolchain.  Though yes, that's minor.

Anyway, please don't let me hold anything up.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Michael Matz]

Hello,

On Tue, 29 Sep 2020, Pedro Alves wrote:

> > Definitely.  But used vs retain attribute seemed like a too detailed 
> > distinction to make at this point.  For the GCC patches it's totally 
> > appropriate, though, as planned.
> 
> It's only planned now because I brought it up.  I think that shooting
> down a subthread like this implying I'm getting in the way is kind of
> uncalled for, to be honest.

Apologies, then, sorry.


Ciao,
Michael.

Re: [PATCH] Support SHF_GNU_RETAIN ELF section flag

[Pedro Alves]

On 9/29/20 3:10 PM, Michael Matz wrote:
> Hello,
> 
> On Tue, 29 Sep 2020, Pedro Alves wrote:
> 
>>> Definitely.  But used vs retain attribute seemed like a too detailed 
>>> distinction to make at this point.  For the GCC patches it's totally 
>>> appropriate, though, as planned.
>>
>> It's only planned now because I brought it up.  I think that shooting
>> down a subthread like this implying I'm getting in the way is kind of
>> uncalled for, to be honest.
> 
> Apologies, then, sorry.

No harm done.

Cheers,
Pedro Alves