[ELF] Define __start_XXX/__stop_XXX symbols where XXX is a section name

[atanasyan]

Summary

This is GNU ELF linker extension used particularly by LibC code. If input object files contain section named XXX and the XXX is a valid C identifier, and there are undefined or weak symbols start_XXX/stop_XXX, linker should define start_XXX/stop_XXX symbols point to the begin/end of the XXX section correspondingly.

For example, without support of this extension statically linked executables for X86_64 and Mips (maybe other) targets do not flush IO buffers at the end of executing.

[ruiu]

LGTM.

I'd think notifyInputSectionName is too generic as a name as this actually serves only one purpose (implementing this feature), but it's up to you.

[atanasyan]

Thanks for review. I agree that the notifyInputSectionName is not the best name for the method but I could not invent anything better except very long variants.

Closed by commit rL241341.

include/lld/ReaderWriter/ELFLinkingContext.h

public:
 
   const llvm::StringSet<> &wrapCalls() const { return _wrapCalls; }
 
   void setUndefinesResolver(std::unique_ptr<File> resolver);
 
   script::Sema &linkerScriptSema() { return _linkerScriptSema; }
   const script::Sema &linkerScriptSema() const { return _linkerScriptSema; }
 
+  /// Notify the ELFLinkingContext when the new ELF section is read.
+  void notifyInputSectionName(StringRef name);
+  /// Encountered C-ident input section names.
+  const llvm::StringSet<> &cidentSectionNames() const {
+    return _cidentSections;
+  }
+
   // Set R_ARM_TARGET1 relocation behaviour
   bool armTarget1Rel() const { return _armTarget1Rel; }
   void setArmTarget1Rel(bool value) { _armTarget1Rel = value; }
 
   // Set R_MIPS_EH relocation behaviour.
   bool mipsPcRelEhRel() const { return _mipsPcRelEhRel; }
   void setMipsPcRelEhRel(bool value) { _mipsPcRelEhRel = value; }
 
protected:
   StringRef _sysrootPath = "";
   StringRef _soname;
   StringRefVector _rpathList;
   StringRefVector _rpathLinkList;
   llvm::StringSet<> _wrapCalls;
   std::map<std::string, uint64_t> _absoluteSymbols;
   llvm::StringSet<> _dynamicallyExportedSymbols;
   std::unique_ptr<File> _resolver;
+  llvm::StringSet<> _cidentSections;
 
   // The linker script semantic object, which owns all script ASTs, is stored
   // in the current linking context via _linkerScriptSema.
   script::Sema _linkerScriptSema;
 };
 
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

if (_ctx.isDynamic()) {
     file->addAbsoluteAtom(gotSymbol);
     file->addAbsoluteAtom(dynamicSymbol);
     result.push_back(std::move(file));
   }
 }
 
 void ARMExecutableWriter::processUndefinedSymbol(
     StringRef symName, RuntimeFile<ELF32LE> &file) const {
+  ARMELFWriter<ExecutableWriter<ELF32LE>>::processUndefinedSymbol(symName,
+                                                                  file);
   if (symName == gotSymbol) {
     file.addAbsoluteAtom(gotSymbol);
   } else if (symName.startswith("__exidx")) {
     file.addAbsoluteAtom("__exidx_start");
     file.addAbsoluteAtom("__exidx_end");
   } else if (symName == "__ehdr_start") {
     file.addAbsoluteAtom("__ehdr_start");
   }
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H

lib/ReaderWriter/ELF/ELFFile.cpp

if (section.sh_type == llvm::ELF::SHT_RELA) {
       if (std::error_code ec = sHdrOrErr.getError())
         return ec;
       auto sHdr = *sHdrOrErr;
       auto ri = _objFile->rel_begin(&section);
       auto re = _objFile->rel_end(&section);
       _relocationReferences[sHdr] = make_range(ri, re);
       totalRelocs += std::distance(ri, re);
     } else {
+      auto sectionName = _objFile->getSectionName(&section);
+      if (std::error_code ec = sectionName.getError())
+        return ec;
+      _ctx.notifyInputSectionName(*sectionName);
       _sectionSymbols[&section];
     }
   }
   _references.reserve(totalRelocs);
   return std::error_code();
 }
 
 template <class ELFT> std::error_code ELFFile<ELFT>::createMergeableAtoms() {

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

 #endif
 }
 
 void ELFLinkingContext::setUndefinesResolver(std::unique_ptr<File> resolver) {
   assert(isa<ArchiveLibraryFile>(resolver.get()) && "Wrong resolver type");
   _resolver = std::move(resolver);
 }
 
+void ELFLinkingContext::notifyInputSectionName(StringRef name) {
+  // Save sections names which can be represented as a C identifier.
+  if (name.find_first_not_of("0123456789"
+                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                             "abcdefghijklmnopqrstuvwxyz"
+                             "_") == StringRef::npos)
+    _cidentSections.insert(name);
+}
+
 } // end namespace lld

lib/ReaderWriter/ELF/OutputELFWriter.h

protected:
 
   /// \brief Create DT_NEEDED dynamic tage for the shared library.
   virtual bool isNeededTagRequired(const SharedLibraryAtom *sla) const {
     return false;
   }
 
   /// \brief Process undefined symbols that left after resolution step.
   virtual void processUndefinedSymbol(StringRef symName,
-                                      RuntimeFile<ELFT> &file) const {}
+                                      RuntimeFile<ELFT> &file) const;
 
   /// \brief Assign addresses to atoms marking section's start and end.
   void updateScopeAtomValues(StringRef sym, StringRef sec);
 
   llvm::BumpPtrAllocator _alloc;
 
   ELFLinkingContext &_ctx;
   TargetHandler &_targetHandler;
protected:
   unique_bump_ptr<DynamicSymbolTable<ELFT>> _dynamicSymbolTable;
   unique_bump_ptr<StringTable<ELFT>> _dynamicStringTable;
   unique_bump_ptr<HashSection<ELFT>> _hashTable;
   llvm::StringSet<> _soNeeded;
   /// @}
 
 private:
   static StringRef maybeGetSOName(Node *node);
+  void updateScopeAtomValues(StringRef start, StringRef end, StringRef sec);
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_OUTPUT_WRITER_H

lib/ReaderWriter/ELF/OutputELFWriter.cpp

const llvm::StringSet<> &symbols =
       _ctx.linkerScriptSema().getScriptDefinedSymbols();
   for (auto &sym : symbols) {
     uint64_t res =
         _ctx.linkerScriptSema().getLinkerScriptExprValue(sym.getKey());
     AtomLayout *a = _layout.findAbsoluteAtom(sym.getKey());
     assert(a);
     a->_virtualAddr = res;
   }
+  // If there is a section named XXX, and XXX is a valid C identifier,
+  // and there are undefined or weak __start_XXX/__stop_XXX symbols,
+  // set the symbols values to the begin/end of the XXX section
+  // correspondingly.
+  for (const auto &name : _ctx.cidentSectionNames())
+    updateScopeAtomValues((Twine("__start_") + name.getKey()).str(),
+                          (Twine("__stop_") + name.getKey()).str(),
+                          name.getKey());
 }
 
 template <class ELFT> void OutputELFWriter<ELFT>::createDefaultSections() {
   _elfHeader.reset(new (_alloc) ELFHeader<ELFT>(_ctx));
   _programHeader.reset(new (_alloc) ProgramHeader<ELFT>(_ctx));
   _layout.setHeader(_elfHeader.get());
   _layout.setProgramHeader(_programHeader.get());
 
std::error_code OutputELFWriter<ELFT>::writeFile(const File &file,
   if (std::error_code ec = buildOutput(file))
     return ec;
   if (std::error_code ec = setELFHeader())
     return ec;
   return writeOutput(file, path);
 }
 
 template <class ELFT>
+void OutputELFWriter<ELFT>::processUndefinedSymbol(
+    StringRef symName, RuntimeFile<ELFT> &file) const {
+  if (symName.startswith("__start_")) {
+    if (_ctx.cidentSectionNames().count(symName.drop_front(8)))
+      file.addAbsoluteAtom(symName);
+  } else if (symName.startswith("__stop_")) {
+    if (_ctx.cidentSectionNames().count(symName.drop_front(7)))
+      file.addAbsoluteAtom(symName);
+  }
+}
+
+template <class ELFT>
 void OutputELFWriter<ELFT>::updateScopeAtomValues(StringRef sym,
                                                   StringRef sec) {
-  std::string start = ("__" + sym + "_start").str();
-  std::string end = ("__" + sym + "_end").str();
+  updateScopeAtomValues(("__" + sym + "_start").str().c_str(),
+                        ("__" + sym + "_end").str().c_str(), sec);
+}
+
+template <class ELFT>
+void OutputELFWriter<ELFT>::updateScopeAtomValues(StringRef start,
+                                                  StringRef end,
+                                                  StringRef sec) {
   AtomLayout *s = _layout.findAbsoluteAtom(start);
   AtomLayout *e = _layout.findAbsoluteAtom(end);
-  OutputSection<ELFT> *section = _layout.findOutputSection(sec);
-  if (!s || !e)
-    return;
-
-  if (section) {
-    s->_virtualAddr = section->virtualAddr();
-    e->_virtualAddr = section->virtualAddr() + section->memSize();
-  } else {
-    s->_virtualAddr = 0;
-    e->_virtualAddr = 0;
-  }
+  const OutputSection<ELFT> *section = _layout.findOutputSection(sec);
+  if (s)
+    s->_virtualAddr = section ? section->virtualAddr() : 0;
+  if (e)
+    e->_virtualAddr = section ? section->virtualAddr() + section->memSize() : 0;
 }
 
 template class OutputELFWriter<ELF32LE>;
 template class OutputELFWriter<ELF32BE>;
 template class OutputELFWriter<ELF64LE>;
 template class OutputELFWriter<ELF64BE>;
 
 } // namespace elf
 } // namespace lld

test/elf/start-stop-sym.test

+# Check __start_XXX and __stop_XXX symbols handling where XXX
+# is a section name which can be represented as a C identifier.
+
+# RUN: yaml2obj -format=elf -docnum 1 %s > %t1.o
+# RUN: yaml2obj -format=elf -docnum 2 %s > %t2.o
+# RUN: lld -flavor gnu -target mipsel -static -e T0 -o %t.exe %t1.o %t2.o
+# RUN: llvm-objdump -s -t %t.exe | FileCheck %s
+
+# CHECK:      Contents of section .text:
+# CHECK-NEXT:  400080 a0004000 b4004000 00000000 00000000
+#                     ^ start of _csec section
+#                              ^ end of _csec section
+# CHECK-NEXT:  400090 a0004000 b4004000
+# CHECK-NEXT: Contents of section _csec:
+# CHECK-NEXT:  4000a0 00000000 00000000 00000000 00000000
+# CHECK-NEXT:  4000b0 00000000
+
+# CHECK: 004000a0  g  *ABS*  00000000 __start__csec
+# CHECK: 004000b4  g  *ABS*  00000000 __stop__csec
+
+---
+FileHeader:
+  Class:    ELFCLASS32
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_MIPS
+  Flags:    [EF_MIPS_CPIC, EF_MIPS_ABI_O32, EF_MIPS_ARCH_32]
+
+Sections:
+  - Name:          .text
+    Type:          SHT_PROGBITS
+    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:  16
+    Size:          8
+
+  - Name:          .rel.text
+    Type:          SHT_REL
+    Link:          .symtab
+    AddressAlign:  4
+    Info:          .text
+    Relocations:
+      - Offset:  0
+        Symbol:  __start__csec
+        Type:    R_MIPS_32
+      - Offset:  4
+        Symbol:  __stop__csec
+        Type:    R_MIPS_32
+
+  - Name:          _csec
+    Type:          SHT_PROGBITS
+    Flags:         [ SHF_ALLOC ]
+    AddressAlign:  16
+    Size:          4
+
+Symbols:
+  Weak:
+    - Name:     __start__csec
+    - Name:     __stop__csec
+  Global:
+    - Name:     T0
+      Type:     STT_FUNC
+      Section:  .text
+      Size:     8
+
+---
+FileHeader:
+  Class:    ELFCLASS32
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_MIPS
+  Flags:    [EF_MIPS_CPIC, EF_MIPS_ABI_O32, EF_MIPS_ARCH_32]
+
+Sections:
+  - Name:          .text
+    Type:          SHT_PROGBITS
+    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:  16
+    Size:          8
+
+  - Name:          .rel.text
+    Type:          SHT_REL
+    Link:          .symtab
+    AddressAlign:  4
+    Info:          .text
+    Relocations:
+      - Offset:  0
+        Symbol:  __start__csec
+        Type:    R_MIPS_32
+      - Offset:  4
+        Symbol:  __stop__csec
+        Type:    R_MIPS_32
+
+  - Name:          _csec
+    Type:          SHT_PROGBITS
+    Flags:         [ SHF_ALLOC ]
+    AddressAlign:  16
+    Size:          4
+
+Symbols:
+  Weak:
+    - Name:     __start__csec
+    - Name:     __stop__csec
+  Global:
+    - Name:     T1
+      Type:     STT_FUNC
+      Section:  .text
+      Size:     8
+...