Incremental linking, ELF, & templates => REDUNDANT CODE

Incremental linking, ELF, & templates => REDUNDANT CODE

[Brad M. Garcia]

I've been under the impression for some time now that when a platform
uses the ELF object format, that all redundant template code (weak
symbols) will cancel out.

This is not (necessarily) true!

It appears that when you do an incremental link (ld -r), this
cancellation will occur during that link, but subsequent links will
fail to cancel redundant code.

When a *.o file is created from a C++ source file, it has a number of
sections called .gnu.linkonce.*.  When the incremental link is attempted,
it appears that redundant copies of these sections are removed, but then
these sections are simply rolled into the .text section of the resulting
*.o file.  Once in the .text section, weak symbols cannot be removed.

This seems like a bug in the linker.  Has anyone heard of a fix?
Am I wrong in my analysis?  I'm using binutils 2.8.1.

Brad Garcia
   ___/  __ /  __ /  ___/ "Being the Linux of digital media
  __/   /  /  / _/  __/    would be a very good life."
_/    ____/ _/ _| ____/      - Jean-Louis Gassee, CEO of Be, Inc.

Re: Incremental linking, ELF, & templates => REDUNDANT CODE

[H.J. Lu]

> This seems like a bug in the linker.  Has anyone heard of a fix?
> Am I wrong in my analysis?  I'm using binutils 2.8.1.
> 

So many bugs have been fixed since 2.8.1. Please try either binutils 2.9
beta or my binutils 2.8.1.0.30. My binutils 2.8.1.0.30 is binutils 2.9
beta plus ARM/ELF and x86 changes.


-- 
H.J. Lu (hjl@gnu.org)

Re: Incremental linking, ELF, & templates => REDUNDANT CODE

[Ian Lance Taylor]

   Date: Fri, 10 Apr 1998 06:56:17 -0400 (EDT)
   From: "Brad M. Garcia" <bgarcia@fore.com>

   It appears that when you do an incremental link (ld -r), this
   cancellation will occur during that link, but subsequent links will
   fail to cancel redundant code.

   When a *.o file is created from a C++ source file, it has a number of
   sections called .gnu.linkonce.*.  When the incremental link is attempted,
   it appears that redundant copies of these sections are removed, but then
   these sections are simply rolled into the .text section of the resulting
   *.o file.  Once in the .text section, weak symbols cannot be removed.

   This seems like a bug in the linker.  Has anyone heard of a fix?
   Am I wrong in my analysis?  I'm using binutils 2.8.1.

This is a bug in the binutils 2.8.1 release.  I believe that it will
be fixed in the upcoming binutils 2.9 release.

Linker bug reports should really go to bug-gnu-utils@gnu.org rather
than egcs@cygnus.com.

Ian

Re: Incremental linking, ELF, & templates => REDUNDANT CODE

[Joe Buck]

> I've been under the impression for some time now that when a platform
> uses the ELF object format, that all redundant template code (weak
> symbols) will cancel out.
> 
> This is not (necessarily) true!
> 
> It appears that when you do an incremental link (ld -r), this
> cancellation will occur during that link, but subsequent links will
> fail to cancel redundant code.

As others have said, the term "incremental link" is usually used in
a different way (when you have an executable and you link in new code
to that executable).  ld -r is usually called "partial linking".
Nevertheless, I think you have a case.

> When a *.o file is created from a C++ source file, it has a number of
> sections called .gnu.linkonce.*.  When the incremental link is attempted,
> it appears that redundant copies of these sections are removed, but then
> these sections are simply rolled into the .text section of the resulting
> *.o file.  Once in the .text section, weak symbols cannot be removed.

It seems that ld -r should work in a different way, choosing one
.gnu.linkonce.* section of each type to copy to the output file
but otherwise leaving them the same.

> This seems like a bug in the linker.  Has anyone heard of a fix?

Well, "bug" is perhaps too strong, but it seems like a misfeature.

Re: Incremental linking, ELF, & templates => REDUNDANT CODE

[Martin von Loewis]

> I've been under the impression for some time now that when a platform
> uses the ELF object format, that all redundant template code (weak
> symbols) will cancel out.
> 
> This is not (necessarily) true!

Indeed. It only works with GNU binutils. As you find, it doesn't
even work always, then.

.gnu.linkonce is a GNU binutils extension to ELF, as the name
suggests.

> This seems like a bug in the linker.  Has anyone heard of a fix?
> Am I wrong in my analysis?  I'm using binutils 2.8.1.

I use 'GNU ld version 2.8.2 (with BFD 980130)', and I can't confirm
your observation. linkonce is processed using the linker script
(e.g. elf_i386.xs):

  .text      :
  {
    *(.text)
    *(.stub)
    /* .gnu.warning sections are handled specially by elf32.em.  */
    *(.gnu.warning)
    *(.gnu.linkonce.t*)
  } =0x9090

In the linker script for relative linking (elf_i386.xr), I find
no special processing for linkonce sections. objdump know another
section flag, LINK_ONCE_DISCARD. Apparently, my ld does the right
thing when relative loading such sections.

Regards,
Martin