[LLD][ELF] Add support for local symbols in Synthetic Sections

[peter.smith]

Summary

A synthetic local symbol is a symbol with STB_LOCAL binding defined in a SyntheticSection. The primary use case for these symbols is to identify Thunks (When support for Thunks as synthetic sections) is added. Another use case is ARM/AArch64 mapping symbols such as $a, $t and $d. These can be added to Thunks and PLT sections to give better disassembly.

For thunks we need to create a symbol in the SyntheticSection representing the Thunk so we can retarget the relocation at it. As functions with STB_LOCAL binding can have the same name, and may need more than one range extension Thunk it simplifies the Thunk implementation if we can make the Thunk symbols have STB_LOCAL binding, and allow non-unique names.

Mapping symbols such as $a, $t and $d are helpful for the disassembler to identify which parts of the Thunk are ARM, Thumb or Data. The ABI allows mapping symbols to have a .suffix which is ignored to account for tools that can't handle non-unique names.

We can already add symbols with STB_LOCAL binding to synthetic sections by using addRegular, however we have to say IsLocal=false in the SymbolBody and we have to have a unique name. These are not fundamental restrictions to implement Thunks or MappingSymbols as in both cases we can make sure the symbol name we add is unique. However I'm not hugely keen on setting IsLocal=false, there is also potential for other SymbolTable processing treating the symbols as if they were global.

As the local symbols are added outside of SymbolTable::Symbols I've incremented NumLocals when adding a synthetic local.

I've added support for adding to mapping symbols to the ARM PLT to test this out.

[peter.smith]

I've not added any uses of adding a local symbol to a synthetic section. I've checked that it works by adding mapping symbols to ARM PLT entries, this is quite a large diff due to test updates so I've not included it in the review. I've attached the patch for reference

pltmappingshort.patch15 KBDownload

[evgeny777]

Looks good, but wait for others, please.

ELF/SyntheticSections.cpp

1143

I'd add lambda which takes 'DefinedRegular<ELFT> *' and call it in both places.

[grimar]

ELF/SyntheticSections.cpp

1152

cast<DefinedRegular<ELFT>> instead ?

[ruiu]

SymbolTable class in SymbolTable.cpp is a class to arbitrate global symbols, and currently it has no interaction with local symbols, because local symbols don't need any symbol name resolution. This patch is using that class as a storage to store synthetic symbols. I found that that's a bit confusing.

Can you move that to SyntheticSections.h or somewhere to make it clear that the symbol table doesn't do any business with local symbols?

[peter.smith]

Removed all code in SymbolTable and rebased the patch on top of D29021.

I've added a function addSyntheticLocal which creates the symbol body and automatically adds it to the SymTab if it exists. This avoids storing the SymbolBodies in a temporary location.

[ruiu]

It looks like this patch does not contain all changes. You defined addSyntehticLocal but you are not using it...?

ELF/SyntheticSections.cpp

292

S -> *S

[peter.smith]

Thanks for the comments. I've updated the diff.

At the moment I only really need addSyntheticLocal for Thunks, I thought it would be best to split that part from the first Thunk patch to get the interface to addSyntheticLocal before submitting the Thunk patch.

To test addSyntheticLocal I've made a patch to add mapping symbols to the PLT section. I've uploaded the whole thing with this patch. I think that this is a worthwhile improvement to the disassembly of the PLT section especially on GNU objdump.

I'm happy to abandon this review and roll in addSyntheticLocal to either the first Thunks patch. Or I'm happy to add the PLT mapping symbols if you'd prefer?

[ruiu]

I think this patch would be useful per se, but I wonder if you emit more than $a or $d? I mean those symbols could include the original symbol names to which these PLT entries jump to at runtime. (But if it is too much or too weird, I'm OK with this patch.)

ELF/Target.cpp

1738–1739 ↗

(On Diff #85420)

Since string constants are not on the stack, I think you don't need to use Saver.

[peter.smith]

That is possible although in many cases the disassembler can derive that information without an additional symbol. For example there is some functionality in GNU objdump to display the symbol name of the PLT from some hard-coded choice of PLT size made when building objdump. For example, from hello world compiled and linked with ld.bfd:

000102ac <puts@plt-0x14>:
   102ac:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   102b0:	e59fe004 	ldr	lr, [pc, #4]	; 102bc <_init+0x1c>
   102b4:	e08fe00e 	add	lr, pc, lr
   102b8:	e5bef008 	ldr	pc, [lr, #8]!
   102bc:	00010288 	.word	0x00010288

000102c0 <puts@plt>:
   102c0:	e28fc600 	add	ip, pc, #0, 12
   102c4:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   102c8:	e5bcf288 	ldr	pc, [ip, #648]!	; 0x288
...

The lld ARM backend uses 4 word plt entries and doesn't get picked up by objdump's recognizer.

For x86 objdump can recognise lld's plt entries

00000000002011b0 <__libc_start_main@plt-0x10>:
  2011b0:	ff 35 62 0e 00 00    	pushq  0xe62(%rip)        # 202018 <__TMC_END__+0x8>
  2011b6:	ff 25 64 0e 00 00    	jmpq   *0xe64(%rip)        # 202020 <__TMC_END__+0x10>
  2011bc:	0f 1f 40 00          	nopl   0x0(%rax)

00000000002011c0 <__libc_start_main@plt>:
  2011c0:	ff 25 62 0e 00 00    	jmpq   *0xe62(%rip)        # 202028 <__TMC_END__+0x18>
  2011c6:	68 00 00 00 00       	pushq  $0x0
  2011cb:	e9 e0 ff ff ff       	jmpq   2011b0 <_fini+0x10>

So I think it probably isn't worth manually adding the symbols with @plt.

[peter.smith]

Updated patch to remove Saver.save for mapping symbol entries.

[ruiu]

LGTM

ELF/SyntheticSections.cpp

292

Please use make<DefinedRegular<ELFT>>(...) instead of new (BAlloc).

1445

Can you add a comment saying that ARM's .plt section usually contains local symbols? That is a foreign concept for those who are familiar only with x86.

ELF/SymbolTable.h

template <class ELFT> class SymbolTable {
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::uint uintX_t;
 
 public:
   void addFile(InputFile *File);
   void addCombinedLTOObject();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
+  ArrayRef<SymbolBody *> getSyntheticLocals() const { return SyntheticLocals; }
   ArrayRef<ObjectFile<ELFT> *> getObjectFiles() const { return ObjectFiles; }
   ArrayRef<BinaryFile *> getBinaryFiles() const { return BinaryFiles; }
   ArrayRef<SharedFile<ELFT> *> getSharedFiles() const { return SharedFiles; }
 
   DefinedRegular<ELFT> *addAbsolute(StringRef Name,
                                     uint8_t Visibility = llvm::ELF::STV_HIDDEN,
                                     uint8_t Binding = llvm::ELF::STB_GLOBAL);
   DefinedRegular<ELFT> *addIgnored(StringRef Name,
                                    uint8_t Visibility = llvm::ELF::STV_HIDDEN);
 
   Symbol *addUndefined(StringRef Name);
   Symbol *addUndefined(StringRef Name, bool IsLocal, uint8_t Binding,
                        uint8_t StOther, uint8_t Type, bool CanOmitFromDynSym,
                        InputFile *File);
 
   Symbol *addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
                      uintX_t Value, uintX_t Size, uint8_t Binding,
                      InputSectionBase<ELFT> *Section, InputFile *File);
 
   Symbol *addSynthetic(StringRef N, const OutputSectionBase *Section,
                        uintX_t Value, uint8_t StOther);
+  // For symbols with STB_LOCAL binding and non-unique symbol names
+  SymbolBody *addSyntheticLocal(StringRef Name, uint8_t StOther, uint8_t Type,
+                                uintX_t Value, uintX_t Size,
+                                InputSectionBase<ELFT> *Section);
 
   void addShared(SharedFile<ELFT> *F, StringRef Name, const Elf_Sym &Sym,
                  const typename ELFT::Verdef *Verdef);
 
   void addLazyArchive(ArchiveFile *F, const llvm::object::Archive::Symbol S);
   void addLazyObject(StringRef Name, LazyObjectFile &Obj);
   Symbol *addBitcode(StringRef Name, uint8_t Binding, uint8_t StOther,
                      uint8_t Type, bool CanOmitFromDynSym, BitcodeFile *File);
private:
   llvm::DenseSet<StringRef> SoNames;
 
   // A map from demangled symbol names to their symbol objects.
   // This mapping is 1:N because two symbols with different versions
   // can have the same name. We use this map to handle "extern C++ {}"
   // directive in version scripts.
   llvm::Optional<llvm::StringMap<std::vector<SymbolBody *>>> DemangledSyms;
 
+  // Symbols with STB_LOCAL binding defined in Synthetic Sections
+  std::vector<SymbolBody *> SyntheticLocals;
+
   // For LTO.
   std::unique_ptr<BitcodeCompiler> LTO;
 };
 
 template <class ELFT> struct Symtab { static SymbolTable<ELFT> *X; };
 template <class ELFT> SymbolTable<ELFT> *Symtab<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/SymbolTable.cpp

int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, STB_GLOBAL,
                                           /*IsAbsolute*/ false, /*Value*/ 0);
   if (Cmp > 0)
     replaceBody<DefinedSynthetic>(S, N, Value, Section);
   else if (Cmp == 0)
     reportDuplicate(S->body(), nullptr);
   return S;
 }
 
+// For non-unique local symbol names defined in Synthetic Sections
+template <typename ELFT>
+SymbolBody *
+SymbolTable<ELFT>::addSyntheticLocal(StringRef Name, uint8_t StOther,
+                                     uint8_t Type, uintX_t Value, uintX_t Size,
+                                     InputSectionBase<ELFT> *Section) {
+  auto S = new (BAlloc) DefinedRegular<ELFT>(
+      Name, /*IsLocal*/ true, StOther, Type, Value, Size, Section, nullptr);
+  SyntheticLocals.push_back(S);
+  return S;
+}
+
 template <typename ELFT>
 void SymbolTable<ELFT>::addShared(SharedFile<ELFT> *F, StringRef Name,
                                   const Elf_Sym &Sym,
                                   const typename ELFT::Verdef *Verdef) {
   // DSO symbols do not affect visibility in the output, so we pass STV_DEFAULT
   // as the visibility, which will leave the visibility in the symbol table
   // unchanged.
   Symbol *S;

ELF/SyntheticSections.h

public:
   typedef typename ELFT::SymRange Elf_Sym_Range;
   typedef typename ELFT::uint uintX_t;
   SymbolTableSection(StringTableSection<ELFT> &StrTabSec);
 
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return getNumSymbols() * sizeof(Elf_Sym); }
   void addSymbol(SymbolBody *Body);
+  void addSyntheticLocal(SymbolBody *Body);
   StringTableSection<ELFT> &getStrTabSec() const { return StrTabSec; }
   unsigned getNumSymbols() const { return NumLocals + Symbols.size() + 1; }
 
   ArrayRef<SymbolTableEntry> getSymbols() const { return Symbols; }
 
   static const OutputSectionBase *getOutputSection(SymbolBody *Sym);
 
   unsigned NumLocals = 0;
   StringTableSection<ELFT> &StrTabSec;
 
 private:
+  void writeLocalSymbol(Elf_Sym *ESym, const DefinedRegular<ELFT> &Body,
+                        size_t StrTabOffset);
   void writeLocalSymbols(uint8_t *&Buf);
   void writeGlobalSymbols(uint8_t *Buf);
 
   // A vector of symbols and their string table offsets.
   std::vector<SymbolTableEntry> Symbols;
+  // For local symbols defined in synthetic sections
+  std::vector<SymbolTableEntry> SyntheticLocals;
 };
 
 // Outputs GNU Hash section. For detailed explanation see:
 // https://blogs.oracle.com/ali/entry/gnu_hash_elf_sections
 template <class ELFT>
 class GnuHashTableSection final : public SyntheticSection<ELFT> {
   typedef typename ELFT::Off Elf_Off;
   typedef typename ELFT::Word Elf_Word;

ELF/SyntheticSections.cpp

template <class ELFT> InputSection<ELFT> *elf::createInterpSection() {
   return Ret;
 }
 
 static size_t getHashSize() {
   switch (Config->BuildId) {
   case BuildIdKind::Fast:
     return 8;
   case BuildIdKind::Md5:
   case BuildIdKind::Uuid:
     return 16;
   case BuildIdKind::Sha1:
     return 20;
   case BuildIdKind::Hexstring:
     return Config->BuildIdVector.size();
   default:
     llvm_unreachable("unknown BuildIdKind");
   }
template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
   for (const SymbolTableEntry &S : Symbols)
     S.Symbol->DynsymIndex = ++I;
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::addSymbol(SymbolBody *B) {
   Symbols.push_back({B, StrTabSec.addString(B->getName(), false)});
 }
 
+template <class ELFT>
+void SymbolTableSection<ELFT>::addSyntheticLocal(SymbolBody *B) {
+  SyntheticLocals.push_back({B, StrTabSec.addString(B->getName())});
+  ++NumLocals;
+}
+
 template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
   Buf += sizeof(Elf_Sym);
 
   // All symbols with STB_LOCAL binding precede the weak and global symbols.
   // .dynsym only contains global symbols.
   if (Config->Discard != DiscardPolicy::All && !StrTabSec.isDynamic())
     writeLocalSymbols(Buf);
 
   writeGlobalSymbols(Buf);
 }
 
 template <class ELFT>
-void SymbolTableSection<ELFT>::writeLocalSymbols(uint8_t *&Buf) {
-  // Iterate over all input object files to copy their local symbols
-  // to the output symbol table pointed by Buf.
-  for (ObjectFile<ELFT> *File : Symtab<ELFT>::X->getObjectFiles()) {
-    for (const std::pair<const DefinedRegular<ELFT> *, size_t> &P :
-         File->KeptLocalSyms) {
-      const DefinedRegular<ELFT> &Body = *P.first;
-      InputSectionBase<ELFT> *Section = Body.Section;
-      auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
+void SymbolTableSection<ELFT>::writeLocalSymbol(
+    Elf_Sym *ESym, const DefinedRegular<ELFT> &Body, size_t StrTabOffset) {
 
-      if (!Section) {
-        ESym->st_shndx = SHN_ABS;
-        ESym->st_value = Body.Value;
-      } else {
-        const OutputSectionBase *OutSec = Section->OutSec;
-        ESym->st_shndx = OutSec->SectionIndex;
-        ESym->st_value = OutSec->Addr + Section->getOffset(Body);
-      }
-      ESym->st_name = P.second;
-      ESym->st_size = Body.template getSize<ELFT>();
-      ESym->setBindingAndType(STB_LOCAL, Body.Type);
+  ESym->st_name = StrTabOffset;
+}
+
+template <class ELFT>
+void SymbolTableSection<ELFT>::writeLocalSymbols(uint8_t *&Buf) {
+  // Iterate over all input object files to copy their local symbols
+  // to the output symbol table pointed by Buf.
+  for (ObjectFile<ELFT> *File : Symtab<ELFT>::X->getObjectFiles()) {
+    for (const std::pair<const DefinedRegular<ELFT> *, size_t> &P :
+         File->KeptLocalSyms) {
+      const DefinedRegular<ELFT> &Body = *P.first;
+      auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
+      writeLocalSymbol(ESym, Body, P.second);
       Buf += sizeof(*ESym);
     }
   }
+  // Write Synthetic Locals
+  for (const SymbolTableEntry &S : SyntheticLocals) {
+    SymbolBody *Body = S.Symbol;
+    auto DR = dyn_cast<DefinedRegular<ELFT>>(Body);
+    auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
+    writeLocalSymbol(ESym, *DR, S.StrTabOffset);
+    Buf += sizeof(*ESym);
+  }
 }
 
 template <class ELFT>
 void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {
   // Write the internal symbol table contents to the output symbol table
   // pointed by Buf.
   auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
   for (const SymbolTableEntry &S : Symbols) {
template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody &Sym) {
   unsigned RelOff = In<ELFT>::RelaPlt->getRelocOffset();
   Entries.push_back(std::make_pair(&Sym, RelOff));
 }
 
 template <class ELFT> size_t PltSection<ELFT>::getSize() const {
   return Target->PltHeaderSize + Entries.size() * Target->PltEntrySize;
 }
 
 template <class ELFT>
 IpltSection<ELFT>::IpltSection()
     : SyntheticSection<ELFT>(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 16,
                              ".plt") {}
 
 template <class ELFT> void IpltSection<ELFT>::writeTo(uint8_t *Buf) {
   // The IRelative relocations do not support lazy binding so no header is
   // needed
   size_t Off = 0;

ELF/Writer.cpp

for (Symbol *S : Symtab<ELFT>::X->getSymbols()) {
 
     if (In<ELFT>::DynSymTab && S->includeInDynsym()) {
       In<ELFT>::DynSymTab->addSymbol(Body);
       if (auto *SS = dyn_cast<SharedSymbol<ELFT>>(Body))
         if (SS->file()->isNeeded())
           In<ELFT>::VerNeed->addSymbol(SS);
     }
   }
+  for (SymbolBody *Body : Symtab<ELFT>::X->getSyntheticLocals())
+    if (In<ELFT>::SymTab && includeInSymtab<ELFT>(*Body))
+      In<ELFT>::SymTab->addSyntheticLocal(Body);
 
   // Do not proceed if there was an undefined symbol.
   if (ErrorCount)
     return;
 
   // So far we have added sections from input object files.
   // This function adds linker-created Out<ELFT>::* sections.
   addPredefinedSections();