ELF2: Implement __start_SECNAME and __stop_SECNAME.

[ruiu]

Summary

If a section name is valid as a C identifier (which is rare because of
the leading '.'), linkers are expected to define start_<secname> and
stop_<secname> symbols. They are at beginning and end of the section,
respectively. This is not requested by the ELF standard, but GNU ld and
gold provide this feature.

[davide]

Rare, maybe, but definitely very useful. Definitely the FreeBSD kernel relies on start/stop and I think also the Linux kernel, although I wouldn't bet on that. The code looks good to me. I would also dump the symbol table to double-check the address of the symbols is the same. I also want to spend some words on this.
In the old linker we had an entire/unfinished pass taking care of start/stop. I know because I spent a fair amount of time trying to understand and finish the feature, without success. Now, could it be I didn't know better, but it looked overly complicated to me at the time. It's nice to see the same feature implemented (without comments) in roughly 10 lines of code.

[majnemer]

ELF/Writer.cpp

513–526

$ can be used in an identifier in clang:

echo 'int x$a;' | clang -x c -fsyntax-only - ; echo $?
0

gcc as well:

echo 'int x$a;' | clang -x c -fsyntax-only - ; echo $?
0

[davide]

I'm not familiar enough with this part of the standard but I always thought C identifiers were only:

• upper/lower case a-z
• digits 0-9
• underscore (_)

I checked doc and it seems to confirm: https://msdn.microsoft.com/en-us/library/e7f8y25b.aspx
I also noticed that this is exactly what gold does. If accepting '$' is an extension or clang is wrong here, I don't know, but I don't think we should accept '$' as valid C identifier in this case.

[davide]

Update: This seems to be GNU C, and even there, it's not guaranteed to be supported on each target https://gcc.gnu.org/onlinedocs/gcc/Dollar-Signs.html

[ruiu]

I'm familiar with this topic because I once wrote a C compiler from scratch myself. That is a GNU extension to the C language. I don't think we want to allow '$' for this linker feature because I don't see the need to do that. If the feature is standardized and the spec require us to handle '$', I'd do, but this is not something like that.

[ruiu]

Add a test for the symbol table

ELF/SymbolTable.h

public:
   }
 
   SymbolBody *addUndefined(StringRef Name);
   SymbolBody *addUndefinedOpt(StringRef Name);
   void addSyntheticSym(StringRef Name,
                        OutputSectionBase<ELFT::Is64Bits> &Section,
                        typename llvm::object::ELFFile<ELFT>::uintX_t Value);
   void addIgnoredSym(StringRef Name);
+  bool isUndefined(StringRef Name);
   void scanShlibUndefined();
 
 private:
   Symbol *insert(SymbolBody *New);
   void addELFFile(ELFFileBase<ELFT> *File);
   void addLazy(Lazy *New);
   void addMemberFile(Lazy *Body);
   void checkCompatibility(std::unique_ptr<InputFile> &File);

ELF/SymbolTable.cpp

 }
 
 template <class ELFT> void SymbolTable<ELFT>::addIgnoredSym(StringRef Name) {
   auto Sym = new (Alloc)
       DefinedAbsolute<ELFT>(Name, DefinedAbsolute<ELFT>::IgnoreUndef);
   resolve(Sym);
 }
 
+template <class ELFT> bool SymbolTable<ELFT>::isUndefined(StringRef Name) {
+  if (SymbolBody *Sym = find(Name))
+    return Sym->isUndefined();
+  return false;
+}
+
 template <class ELFT>
 void SymbolTable<ELFT>::addELFFile(ELFFileBase<ELFT> *File) {
   if (auto *O = dyn_cast<ObjectFile<ELFT>>(File))
     ObjectFiles.emplace_back(O);
   else if (auto *S = dyn_cast<SharedFile<ELFT>>(File))
     SharedFiles.emplace_back(S);
 
   if (auto *O = dyn_cast<ObjectFile<ELFT>>(File)) {

ELF/Writer.cpp

 #include "Config.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
private:
   bool isOutputDynamic() const {
     return !Symtab.getSharedFiles().empty() || Config->Shared;
   }
   uintX_t getVAStart() const { return Config->Shared ? 0 : Target->getVAStart(); }
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
   SpecificBumpPtrAllocator<OutputSection<ELFT>> SecAlloc;
+  BumpPtrAllocator Alloc;
   std::vector<OutputSectionBase<ELFT::Is64Bits> *> OutputSections;
   unsigned getNumSections() const { return OutputSections.size() + 1; }
 
+  void addStartStopSymbols(OutputSection<ELFT> *Sec);
   void setPhdr(Elf_Phdr *PH, uint32_t Type, uint32_t Flags, uintX_t FileOff,
                uintX_t VA, uintX_t Align);
   void copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT::Is64Bits> *From);
 
   SymbolTable<ELFT> &Symtab;
   std::vector<Elf_Phdr> Phdrs;
 
   uintX_t FileSize;
template <class ELFT> void Writer<ELFT>::createSections() {
 
   // __tls_get_addr is defined by the dynamic linker for dynamic ELFs. For
   // static linking the linker is required to optimize away any references to
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
   if (!isOutputDynamic())
     Symtab.addIgnoredSym("__tls_get_addr");
 
+  std::vector<OutputSection<ELFT> *> RegularSections;
+
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
     for (InputSection<ELFT> *C : F->getSections()) {
       if (!C || C == &InputSection<ELFT>::Discarded)
         continue;
       const Elf_Shdr *H = C->getSectionHdr();
       uintX_t OutFlags = H->sh_flags & ~SHF_GROUP;
       SectionKey<ELFT::Is64Bits> Key{getOutputName(C->getSectionName()),
                                      H->sh_type, OutFlags};
       OutputSection<ELFT> *&Sec = Map[Key];
       if (!Sec) {
         Sec = new (SecAlloc.Allocate())
             OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
         OutputSections.push_back(Sec);
+        RegularSections.push_back(Sec);
       }
       Sec->addSection(C);
       scanRelocs(*C);
     }
   }
 
+  for (OutputSection<ELFT> *Sec : RegularSections)
+    addStartStopSymbols(Sec);
+
   Out<ELFT>::Dynamic->PreInitArraySec =
       Map.lookup({".preinit_array", SHT_PREINIT_ARRAY, SHF_WRITE | SHF_ALLOC});
   Out<ELFT>::Dynamic->InitArraySec =
       Map.lookup({".init_array", SHT_INIT_ARRAY, SHF_WRITE | SHF_ALLOC});
   Out<ELFT>::Dynamic->FiniArraySec =
       Map.lookup({".fini_array", SHT_FINI_ARRAY, SHF_WRITE | SHF_ALLOC});
 
   auto AddStartEnd = [&](StringRef Start, StringRef End,
template <class ELFT> void Writer<ELFT>::createSections() {
   }
 
   // If we have a .opd section (used under PPC64 for function descriptors),
   // store a pointer to it here so that we can use it later when processing
   // relocations.
   Out<ELFT>::Opd = Map.lookup({".opd", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC});
 }
 
+static bool isAlpha(char C) {
+  return ('a' <= C && C <= 'z') || ('A' <= C && C <= 'Z') || C == '_';
+}
+
+static bool isAlnum(char C) {
+  return isAlpha(C) || ('0' <= C && C <= '9');
+}
+
+// Returns true if S is valid as a C identifier.
+static bool isValidCIdentifier(StringRef S) {
+  if (S.empty() || !isAlpha(S[0]))
+    return false;
+  return std::all_of(S.begin() + 1, S.end(), isAlnum);
+}
+
+// If a section name is valid as a C identifier (which is rare because of
+// the leading '.'), linkers are expected to define __start_<secname> and
+// __stop_<secname> symbols. They are at beginning and end of the section,
+// respectively. This is not requested by the ELF standard, but GNU ld and
+// gold provide this feature.
+template <class ELFT>
+void Writer<ELFT>::addStartStopSymbols(OutputSection<ELFT> *Sec) {
+  StringRef S = Sec->getName();
+  if (!isValidCIdentifier(S))
+    return;
+  StringSaver Saver(Alloc);
+  StringRef Start = Saver.save("__start_" + S);
+  if (Symtab.isUndefined(Start))
+    Symtab.addSyntheticSym(Start, *Sec, 0);
+  StringRef Stop = Saver.save("__stop_" + S);
+  if (Symtab.isUndefined(Stop))
+    Symtab.addSyntheticSym(Stop, *Sec, Sec->getSize());
+}
+
 template <class ELFT>
 static bool needsPhdr(OutputSectionBase<ELFT::Is64Bits> *Sec) {
   return Sec->getFlags() & SHF_ALLOC;
 }
 
 // Visits all sections to assign incremental, non-overlapping RVAs and
 // file offsets.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {

test/elf2/startstop.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+// RUN: ld.lld2 %t -o %tout
+// RUN: llvm-objdump -d %tout | FileCheck -check-prefix=DISASM %s
+// RUN: llvm-readobj -symbols %tout | FileCheck -check-prefix=SYMBOL %s
+
+// DISASM: _start:
+// DISASM:    11000:       e8 0a 00 00 00  callq   10
+// DISASM:    11005:       e8 08 00 00 00  callq   8
+// DISASM:    1100a:       e8 03 00 00 00  callq   3
+// DISASM: Disassembly of section foo:
+// DISASM: __start_foo:
+// DISASM:    1100f:       90      nop
+// DISASM:    11010:       90      nop
+// DISASM:    11011:       90      nop
+// DISASM: Disassembly of section bar:
+// DISASM: __start_bar:
+// DISASM:    11012:       90      nop
+// DISASM:    11013:       90      nop
+// DISASM:    11014:       90      nop
+
+// SYMBOL: Symbol {
+// SYMBOL:   Name: __start_bar
+// SYMBOL:   Value: 0x11012
+// SYMBOL:   Section: bar
+// SYMBOL: }
+// SYMBOL-NOT:   Section: __stop_bar
+// SYMBOL: Symbol {
+// SYMBOL:   Name: __start_foo
+// SYMBOL:   Value: 0x1100F
+// SYMBOL:   Section: foo
+// SYMBOL: }
+// SYMBOL: Symbol {
+// SYMBOL:   Name: __stop_foo
+// SYMBOL:   Value: 0x11012
+// SYMBOL:   Section: foo (0x2)
+// SYMBOL: }
+
+.global _start
+.text
+_start:
+  call __start_foo
+  call __stop_foo
+  call __start_bar
+
+.section foo,"ax"
+  nop
+  nop
+  nop
+
+.section bar,"ax"
+  nop
+  nop
+  nop