[ELF] Convert linker generated sections to input sections

[evgeny777]

Summary

ld/gold allow using linker generated sections as inputs to create some other output sections, for example:

SECTIONS {
  .got : { *(.got.plt) *(.got) }
}

This will create single output section .got with contents of linker generated .got and .got.plt section. This patch makes it possible to do the same
This is done by means of using 'proxy' input section, which holds pointer to linker generated section and can be added to OutputSection<ELFT>,
just like any other regular input section can. In future this can also be used to create single output section for mergeable/non-mergeable inputs,
if linker script demands this.

[grimar]

ELF/InputSection.h

342

Do you need/use this typedefs ?

test/ELF/linkerscript/output-to-input.s

17

Do you really need to specify order of sections to demonstrate output with/without merging of .got/got.plt ?
I mean shouldn't next work ?

# RUN: echo "SECTIONS { \
# RUN:  .got : {} \
# RUN:  .got.plt : {} \
# RUN: }" > %t1.script

# RUN: echo "SECTIONS { \
# RUN:  .got : { *(.got) *(.got.plt)  } \
# RUN: }" > %t2.script

43

Last 32 bytes you mean ? (3 + 1) entries * 8.

[evgeny777]

test/ELF/linkerscript/output-to-input.s

17

You should have equal offsets between .plt and .got.plt section in both cases to get same contents of .got.plt.
Of course it's possible to create smaller examples with the same effect, but in this case result would depend on orphan
section placement algorithm

43

You're right - that's a mistake.

[evgeny777]

Addressed review comments

[ruiu]

In what situation you would want to put both .got and .got.plt to a .got section? I mean, if you want to handle

.got { *(.got) }

we can just ignore such commands.

[evgeny777]

The reason I'm doing this is that I have same linker script for armv7 and aarch64 and all linkers (gold/ld/lld). This script should enforce two constraints:

1. PLT GOT entries should go before all other GOT entries
2. I need to have start and end symbols for GOT

Both constraints need to be enforced for dynamic loader to work properly. Currently I have something like this in my linker script:

.got  : { 
   PROVIDE_HIDDEN(__got_start = .);
   *(.got.plt) *(.got) 
   PROVIDE_HIDDEN(__got_end = .);
}

The problems I face with current version are:

1. On armv7 neither gold nor ld create .got.plt section, but lld does.
2. On aarch64 all linkers create .got.plt, but on some occasions lld doesn't create .got section, while ld/gold do. Also, even if I specify correct order in linker script sometimes orphan section may be placed in between .got.plt and .got and prevent DSO from being correctly loaded.

BTW it looks like both gold and ld allow placing all linker generated sections wherever you want. May be it makes sense to make this patch more generic?

[ruiu]

Honestly I think I wouldn't want to support this unless it is absolutely necessary or there's a better way to support it than the "virtual input section".

First, the SECTIONS command seems odd. The SECTIONS command is to gather input sections to put them into an output section, but there are no .got nor .got.plt sections are in any input file. Therefore, even though

SECTIONS .got { *(.got) }

looks similar to

SECTIONS .text { *(.text) },

they are very different in semantics. The latter aggregates all .text sections from input files to put them into a .text section, but the former instructs the linker to put a linker-created .got section to .got. The former pattern seems semantically wrong and beyond the limit what we could do with the SECTIONS command.

Second, wrapping an output section with a "virtual" input section seems pretty odd, too. That's a direct consequence of the oddity of the feature, but output sections are not input sections, so it's really confusing.

[evgeny777]

Converted .got and .got.plt sections to inputs according to RFC from Rui Ueyama. All tests pass.

[ruiu]

I think this is still too large to see whether the very concept of virtual input section is good or not. GOT section is used everywhere, so you had to update so many places to convert it. Could you convert much less important section first? Say, build-id?

ELF/InputSection.h

359

Does Header = {}; initialize with zero?

[evgeny777]

ELF/InputSection.h

359

Yes, but unfortunately base class is initialized first and it is using Header.

[evgeny777]

Converted BuildId section to input.

[peter.smith]

Apologies in advance if I'm missing something, but I'm not completely sure why we need a special SyntheticInputSection?
Is it because we want to retain a similar custom interface to make generating the Section easier, while still allowing it to be placed as an InputSection? Or is it to get around the lack of an InputFile for the SyntheticInputSection? If it is the latter I would have thought a single SyntheticInputFile might be less disruptive.

Another possible use case of linker generated InputSections is Thunks (or other linker generated code sequences/data) as InputSections, which would need to be mixed in with other InputSections from the file. Would this be possible with SyntheticInputSections?

As an aside for ARM PLT and GOT sections:

I've not got a good reason for why ARM only uses a single .got section on ld.bfd and gold. A best guess is that ARM also had to support Symbian OS at the time which only had a single .got section. At the time of doing the initial ARM port I thought about making a single .got section to match gold and ld.bfd, but given the tests I've been running against ld-linux-armhf.so.3 haven't caused a problem I didn't think it worth the additional disruption to the code-base. Is there a widespread use case where this doesn't work?

[evgeny777]

Thanks for your comment, Peter.

a) SyntheticInputSection is actually a helper class to simplify conversion from output section to input section. It doesn't have any other purpose, just helper constructor and base interface which is partially moved from OutputSectionBase<ELFT>.

b) AFAIK thunks in lld are created in a different way: no input section is created for them, instead there is an array of Thunk<ELFT> objects which is member of InputSection<ELFT> class. This array is used to determine real section size. Real thunk code is generated when sections are written.

c) Like I said earlier both ld and gold don't generate .got section on 32 bit ARM platforms. I don't know if this would ever change. On the other hand lld sometimes doesn't create .got section when both ld and gold do. To abstract differences between 32 and 64 bit ARM we merge .got and .got.plt to a single section in linker scripts. Both gold and ld allow doing this. Another possible usage of this patch is discarding certain linker generated section in linker script, which can't be done now.

[ruiu]

Overall, this is towards the right direction. Please rebase on SVN head because Rafael made a few changes that you can use in this patch.

ELF/Writer.cpp

780

Remove null check. Sections shouldn't contain a nullptr.

858

Why do you have to call S->Outsec->assignOffsets?

1483

You want to use needed() for consistency.

[evgeny777]

ELF/Writer.cpp

780

Actually they can. In original version if build-id section is not emitted then Out<ELFT>::BuildId is nullptr. isDiscarded() does check for nullptr as well

858

In order for OutSec to have non-zero size. Normally assignOffsets is called earlier in createSections().

1483

I've removed needed() in upcoming diff, because it isn't required for BuildIdSection.

[evgeny777]

Addressed review comments

[ruiu]

ELF/InputSection.cpp

816

Here, you fill the internal buffer with data, which to be memcpy'ed to the final output buffer. I think we don't want to do that. Instead, we want to virtualize InputFile's writeTo so that each input section will directly write to the output buffer.

ELF/InputSection.h

247–248

This field is very specific to build-id, which needs to back-fill the buildid value after we get a complete output file. No other sections should need them, and that's a good thing because it keeps most sections being agnostic where they are written. So I'd move this to BuildIdSection, as it used to be.

[evgeny777]

ELF/InputSection.cpp

816

Besides writeTo one will also have to virtualize getSize(), in order for assignOffsets to work properly

[evgeny777]

ELF/InputSection.cpp

816

Also if you virtualize getSize() then you'll get different values from Data.size() and getSize(). The getDataAs<T> won't work either. Does extra copying really provide that much overhead ?

[ruiu]

LGTM

ELF/InputSection.cpp

816

I don't know about that. We might want to create a large virtual section, but I don't have a concrete example now. Because this patch is pretty straightforward and simple, let's land this. We can revisit later.

[evgeny777]

ELF/InputSection.cpp

816

Ok. Does it make sense to convert other sections (like .got and .got.plt) now ?

[ruiu]

Yes, but please do one at a time at the moment.

ELF/InputSection.h

public:
 
   // The garbage collector sets sections' Live bits.
   // If GC is disabled, all sections are considered live by default.
   InputSectionData(Kind SectionKind, StringRef Name, ArrayRef<uint8_t> Data,
                    bool Compressed, bool Live)
       : SectionKind(SectionKind), Live(Live), Compressed(Compressed),
         Name(Name), Data(Data) {}
 
+  virtual ~InputSectionData() = default;
+
 private:
   unsigned SectionKind : 3;
 
 public:
   Kind kind() const { return (Kind)SectionKind; }
 
   // Used for garbage collection.
   unsigned Live : 1;
template <class ELFT> class InputSection : public InputSectionBase<ELFT> {
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::uint uintX_t;
 
 public:
   InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header, StringRef Name);
 
   // Write this section to a mmap'ed file, assuming Buf is pointing to
   // beginning of the output section.
-  void writeTo(uint8_t *Buf);
+  virtual void writeTo(uint8_t *Buf);
 
   // Relocation sections that refer to this one.
   llvm::TinyPtrVector<const Elf_Shdr *> RelocSections;
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutSecOff = 0;
 
   // InputSection that is dependent on us (reverse dependency for GC)
   InputSectionBase<ELFT> *DependentSection = nullptr;
 
   static bool classof(const InputSectionBase<ELFT> *S);
 
   InputSectionBase<ELFT> *getRelocatedSection();
 
   // Register thunk related to the symbol. When the section is written
   // to a mmap'ed file, target is requested to write an actual thunk code.
   // Now thunks is supported for MIPS and ARM target only.
public:
 
   // The singleton instance of this class.
   static CommonInputSection<ELFT> *X;
 
 private:
   static typename ELFT::Shdr Hdr;
 };
 
+// Virtual input section object, which allows using any output section
+// as regular input section for OutputSection<ELFT>.
+template <class ELFT> class ProxyInputSection : public InputSection<ELFT> {
+public:
+  ProxyInputSection(OutputSectionBase<ELFT> *OutSec);
+
+  void writeTo(uint8_t *Buf) override;
+  void finalize();
+  void assignTargetAddress();
+
+  OutputSectionBase<ELFT> *TargetSec;
+
+private:
+  typename ELFT::Shdr Hdr;
+};
+
 template <class ELFT> CommonInputSection<ELFT> *CommonInputSection<ELFT>::X;
 template <class ELFT> typename ELFT::Shdr CommonInputSection<ELFT>::Hdr;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/InputSection.cpp

for (DefinedCommon *Sym : Syms) {
     Hdr.sh_size = alignTo(Hdr.sh_size, Sym->Alignment);
 
     // Compute symbol offset relative to beginning of input section.
     Sym->Offset = Hdr.sh_size;
     Hdr.sh_size += Sym->Size;
   }
 }
 
+template <class T> static T *zero(T *V) {
+  return static_cast<T *>(memset(V, 0, sizeof(*V)));
+}
+
+template <class ELFT>
+ProxyInputSection<ELFT>::ProxyInputSection(OutputSectionBase<ELFT> *OutSec)
+    : InputSection<ELFT>(nullptr, zero(&Hdr), OutSec->getName()),
+      TargetSec(OutSec) {
+
+  Hdr.sh_addralign = this->Alignment = TargetSec->getAlignment();
+  Hdr.sh_type = TargetSec->getType();
+  Hdr.sh_flags = TargetSec->getFlags();
+}
+
+template <class ELFT> void ProxyInputSection<ELFT>::finalize() {
+  if (this->OutSec) {
+    TargetSec->finalize();
+    Hdr.sh_size = TargetSec->getSize();
+  }
+}
+
+template <class ELFT> void ProxyInputSection<ELFT>::writeTo(uint8_t *Buf) {
+  TargetSec->writeTo(Buf + this->OutSecOff);
+}
+
+template <class ELFT> void ProxyInputSection<ELFT>::assignTargetAddress() {
+  if (this->OutSec)
+    TargetSec->setVA(this->OutSec->getVA() + this->OutSecOff);
+}
+
 template class elf::InputSectionBase<ELF32LE>;
 template class elf::InputSectionBase<ELF32BE>;
 template class elf::InputSectionBase<ELF64LE>;
 template class elf::InputSectionBase<ELF64BE>;
 
 template class elf::InputSection<ELF32LE>;
 template class elf::InputSection<ELF32BE>;
 template class elf::InputSection<ELF64LE>;

 template class elf::MipsAbiFlagsInputSection<ELF32BE>;
 template class elf::MipsAbiFlagsInputSection<ELF64LE>;
 template class elf::MipsAbiFlagsInputSection<ELF64BE>;
 
 template class elf::CommonInputSection<ELF32LE>;
 template class elf::CommonInputSection<ELF32BE>;
 template class elf::CommonInputSection<ELF64LE>;
 template class elf::CommonInputSection<ELF64BE>;
+
+template class elf::ProxyInputSection<ELF32LE>;
+template class elf::ProxyInputSection<ELF32BE>;
+template class elf::ProxyInputSection<ELF64LE>;
+template class elf::ProxyInputSection<ELF64BE>;

ELF/LinkerScript.h

 
 namespace lld {
 namespace elf {
 class DefinedCommon;
 class ScriptParser;
 class SymbolBody;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class InputSection;
+template <class ELFT> class ProxyInputSection;
 template <class ELFT> class OutputSectionBase;
 template <class ELFT> class OutputSectionFactory;
 class InputSectionData;
 
 // This represents an expression in the linker script.
 // ScriptParser::readExpr reads an expression and returns an Expr.
 // Later, we evaluate the expression by calling the function
 // with the value of special context variable ".".
public:
   bool hasPhdrsCommands();
   uint64_t getOutputSectionAddress(StringRef Name) override;
   uint64_t getOutputSectionSize(StringRef Name) override;
   uint64_t getOutputSectionAlign(StringRef Name) override;
   uint64_t getOutputSectionLMA(StringRef Name) override;
   uint64_t getHeaderSize() override;
   uint64_t getSymbolValue(StringRef S) override;
   bool isDefined(StringRef S) override;
+  bool convertedToInputSection(OutputSectionBase<ELFT> *OutSec);
 
   std::vector<OutputSectionBase<ELFT> *> *OutputSections;
+  std::vector<ProxyInputSection<ELFT> *> ProxyInputs;
 
   int getSectionIndex(StringRef Name);
 
 private:
   void computeInputSections(InputSectionDescription *);
 
   void addSection(OutputSectionFactory<ELFT> &Factory,
                   InputSectionBase<ELFT> *Sec, StringRef Name);

ELF/LinkerScript.cpp

for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
 
       for (InputSectionBase<ELFT> *S : F->getSections())
         if (!isDiscarded(S) && !S->OutSec && Pat.SectionRe.match(S->Name))
           I->Sections.push_back(S);
       if (Pat.SectionRe.match("COMMON"))
         I->Sections.push_back(CommonInputSection<ELFT>::X);
     }
 
+    for (InputSectionBase<ELFT> *S : ProxyInputs)
+      if (I->FileRe.match(Config->OutputFile) && Pat.SectionRe.match(S->Name))
+        I->Sections.push_back(S);
+
     // Sort sections as instructed by SORT-family commands and --sort-section
     // option. Because SORT-family commands can be nested at most two depth
     // (e.g. SORT_BY_NAME(SORT_BY_ALIGNMENT(.text.*))) and because the command
     // line option is respected even if a SORT command is given, the exact
     // behavior we have here is a bit complicated. Here are the rules.
     //
     // 1. If two SORT commands are given, --sort-section is ignored.
     // 2. If one SORT command is given, and if it is not SORT_NONE,
if (Pos == E) {
       continue;
     }
 
     // Continue from where we found it.
     CmdIndex = (Pos - Opt.Commands.begin()) + 1;
     continue;
   }
 
+  // Assign size to proxy input sections.
+  for (ProxyInputSection<ELFT> *PS : ProxyInputs)
+    PS->finalize();
+
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   Dot = 0;
 
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get())) {
       if (Cmd->Name == ".") {
         Dot = Cmd->Expression(Dot);
       } else if (Cmd->Sym) {
for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     auto *Cmd = cast<OutputSectionCommand>(Base.get());
 
     if (Cmd->AddrExpr)
       Dot = Cmd->AddrExpr(Dot);
 
     assignOffsets(Cmd);
   }
 
+  // Assign proxy target VA to allow DT_PLTGOT be
+  // correctly set.
+  for (ProxyInputSection<ELFT> *PS : ProxyInputs)
+    PS->assignTargetAddress();
+
   uintX_t MinVA = std::numeric_limits<uintX_t>::max();
   for (OutputSectionBase<ELFT> *Sec : *OutputSections) {
     if (Sec->getFlags() & SHF_ALLOC)
       MinVA = std::min(MinVA, Sec->getVA());
     else
       Sec->setVA(0);
   }
 
template <class ELFT> uint64_t LinkerScript<ELFT>::getSymbolValue(StringRef S) {
   error("symbol not found: " + S);
   return 0;
 }
 
 template <class ELFT> bool LinkerScript<ELFT>::isDefined(StringRef S) {
   return Symtab<ELFT>::X->find(S) != nullptr;
 }
 
+template <class ELFT>
+bool LinkerScript<ELFT>::convertedToInputSection(
+    OutputSectionBase<ELFT> *OutSec) {
+  for (ProxyInputSection<ELFT> *PS : ProxyInputs)
+    if (PS->TargetSec == OutSec && PS->OutSec)
+      return true;
+
+  return false;
+}
+
 // Returns indices of ELF headers containing specific section, identified
 // by Name. Each index is a zero based number of ELF header listed within
 // PHDRS {} script block.
 template <class ELFT>
 std::vector<size_t> LinkerScript<ELFT>::getPhdrIndices(StringRef SectionName) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get());
     if (!Cmd || Cmd->Name != SectionName)

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   addReservedSymbols();
 
   if (Target->NeedsThunks)
     forEachRelSec(createThunks<ELFT>);
 
   CommonInputSection<ELFT> Common(getCommonSymbols<ELFT>());
   CommonInputSection<ELFT>::X = &Common;
 
+  ProxyInputSection<ELFT> GotInput(Out<ELFT>::Got);
+  ProxyInputSection<ELFT> GotPltInput(Out<ELFT>::GotPlt);
+
+  Script<ELFT>::X->ProxyInputs = {&GotInput, &GotPltInput};
   Script<ELFT>::X->OutputSections = &OutputSections;
   if (ScriptConfig->HasSections) {
     Script<ELFT>::X->createSections(Factory);
   } else {
     createSections();
     Script<ELFT>::X->processCommands(Factory);
   }
 
while (NonScriptI != E) {
     std::rotate(FirstGreater, NonScriptI, NonScriptI + 1);
     ++NonScriptI;
     ++I;
   }
 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::finalizeSections() {
   Out<ELFT>::PreinitArray = findSection(".preinit_array");
   Out<ELFT>::InitArray = findSection(".init_array");
   Out<ELFT>::FiniArray = findSection(".fini_array");
 
   // The linker needs to define SECNAME_start, SECNAME_end and SECNAME_stop
   // symbols for sections, so that the runtime can get the start and end
   // addresses of each section by section name. Add such symbols.
   if (!Config->Relocatable) {
     addStartEndSymbols();
for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     Sec->SectionIndex = I++;
     Sec->setSHName(Out<ELFT>::ShStrTab->addString(Sec->getName()));
   }
 
   // Finalizers fix each section's size.
   // .dynsym is finalized early since that may fill up .gnu.hash.
   if (Out<ELFT>::DynSymTab)
     Out<ELFT>::DynSymTab->finalize();
 
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections. The dynamic string table is
   // finalized once the .dynamic finalizer has added a few last
   // strings. See DynamicSection::finalize()
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     if (Sec != Out<ELFT>::DynStrTab && Sec != Out<ELFT>::Dynamic)
       Sec->finalize();
template <class ELFT> bool Writer<ELFT>::needsGot() {
   // If we have a relocation that is relative to GOT (such as GOTOFFREL),
   // we need to emit a GOT even if it's empty.
   return Out<ELFT>::Got->HasGotOffRel;
 }
 
 // This function add Out<ELFT>::* sections to OutputSections.
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
   auto Add = [&](OutputSectionBase<ELFT> *OS) {
-    if (OS)
+    if (OS && !Script<ELFT>::X->convertedToInputSection(OS))
       OutputSections.push_back(OS);
   };
 
   // A core file does not usually contain unmodified segments except
   // the first page of the executable. Add the build ID section to beginning of
   // the file so that the section is included in the first page.
   if (Out<ELFT>::BuildId)
     OutputSections.insert(OutputSections.begin(), Out<ELFT>::BuildId);
template <class ELFT> void Writer<ELFT>::writeSections() {
 
   // The .eh_frame_hdr depends on .eh_frame section contents, therefore
   // it should be written after .eh_frame is written.
   if (!Out<ELFT>::EhFrame->empty() && Out<ELFT>::EhFrameHdr)
     Out<ELFT>::EhFrameHdr->writeTo(Buf + Out<ELFT>::EhFrameHdr->getFileOff());
 }
 
 template <class ELFT> void Writer<ELFT>::writeBuildId() {
   if (!Out<ELFT>::BuildId)
     return;
 
   // Compute a hash of all sections of the output file.
   uint8_t *Start = Buffer->getBufferStart();
   uint8_t *End = Start + FileSize;
   Out<ELFT>::BuildId->writeBuildId({Start, End});
 }
 

test/ELF/linkerscript/output-to-input.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+## First script just sets fixed section order
+# RUN: echo "SECTIONS { \
+# RUN:  .dynsym : {} \
+# RUN:  .hash : {} \
+# RUN:  .dynsttr : {} \
+# RUN:  .rela.dyn : {} \
+# RUN:  .rela.plt : {} \
+# RUN:  .text : { *(.text) } \
+# RUN:  .plt : {} \
+# RUN:  .dynamic : {} \
+# RUN:  .got : {} \
+# RUN:  .got.plt : {} \
+# RUN: }" > %t1.script
+
+## Second script just sets the same section order, except
+## .got and .got.plt are now merged to a single section
+# RUN: echo "SECTIONS { \
+# RUN:  .dynsym : {} \
+# RUN:  .hash : {} \
+# RUN:  .dynsttr : {} \
+# RUN:  .rela.dyn : {} \
+# RUN:  .rela.plt : {} \
+# RUN:  .text : { *(.text) } \
+# RUN:  .plt : {} \
+# RUN:  .dynamic : {} \
+# RUN:  .got : { *(.got) *(.got.plt)  } \
+# RUN: }" > %t2.script
+
+# RUN: ld.lld -o %t1 --script %t1.script -shared %t
+# RUN: llvm-objdump -s -j .got.plt %t1 | FileCheck --check-prefix=GOTPLT %s
+
+# GOTPLT:      Contents of section .got.plt:
+# GOTPLT-NEXT: 01b8 e0000000 00000000 00000000 00000000
+# GOTPLT-NEXT: 01c8 00000000 00000000 c6000000 00000000
+
+# RUN: ld.lld -o %t2 --script %t2.script -shared %t
+# RUN: llvm-objdump -s -j .got %t2 | FileCheck --check-prefix=GOT %s
+
+## Last 32 bytes of .got section should be equal to contents
+## of .got.plt section from previous test.
+# GOT:         Contents of section .got:
+# GOT-NEXT:    01b0 00000000 00000000 e0000000 00000000
+# GOT-NEXT:    01c0 00000000 00000000 00000000 00000000
+# GOT-NEXT:    01d0 c6000000 00000000
+
+mov bar@gotpcrel(%rip), %rax
+call foo@plt