handle global strings in merge string sections

[shankarke]

Summary

Handles global strings in merge string sections. With this patch, helloworld on x86_64/hexagon.

[Bigcheese]

Looks good with the changes.

lib/ReaderWriter/ELF/File.h

417–418

Why are we treating them as defined? So they don't get merged away? This comment should explain why.

lib/ReaderWriter/ELF/TargetHandler.h

71

They are always referred to as relocations in ELF.

test/elf/mergeglobalatoms.objtxt

1

This file should be named .test, not .objtxt.

[shankarke]

lib/ReaderWriter/ELF/File.h

417–418

These atoms dont get merged away as well. Also take part in symbol resolution as they are defined atoms.

lib/ReaderWriter/ELF/TargetHandler.h

71

will change it to relocAddend

test/elf/mergeglobalatoms.objtxt

1

ok

[Eugene.Zelenko]

Committed in rL175636.

lib/ReaderWriter/ELF/File.h

for (; it != ie; it.increment(EC)) {
         return;
 
       if ((EC = it->getSection(sit)))
         return;
 
       const Elf_Shdr *section = _objFile->getElfSection(sit);
       const Elf_Sym *symbol = _objFile->getElfSymbol(it);
 
-      // If its a merge section, the atoms have already 
-      // been created, lets not create the atoms again
-      if (doStringsMerge) {
-        int64_t sectionFlags = section->sh_flags;
-        sectionFlags &= ~llvm::ELF::SHF_ALLOC;
-        if ((section->sh_entsize < 2) &&
-            (sectionFlags == (llvm::ELF::SHF_MERGE | llvm::ELF::SHF_STRINGS))) {
-          continue;
-        }
-      }
-
       StringRef symbolName;
       if ((EC = _objFile->getSymbolName(section, symbol, symbolName)))
         return;
 
       if (symbol->st_shndx == llvm::ELF::SHN_ABS) {
         // Create an absolute atom.
         auto *newAtom = new (_readerStorage)
             ELFAbsoluteAtom<ELFT>(*this, symbolName, symbol, symbol->st_value);
for (auto &i : sectionSymbols) {
       ELFDefinedAtom<ELFT> *previous_atom = nullptr;
 
       // i.first is the section the symbol lives in
       for (auto si = symbols.begin(), se = symbols.end(); si != se; ++si) {
         StringRef symbolName;
         if ((EC = _objFile->getSymbolName(i.first, *si, symbolName)))
           return;
 
+        const Elf_Shdr *section = _objFile->getSection(*si);
+
         bool isCommon = (*si)->getType() == llvm::ELF::STT_COMMON ||
                         (*si)->st_shndx == llvm::ELF::SHN_COMMON;
 
         DefinedAtom::ContentType c;
 
         if (((*si)->st_shndx >= llvm::ELF::SHN_LOPROC) &&
             ((*si)->st_shndx <= llvm::ELF::SHN_HIPROC)) {
           TargetHandler<ELFT> &TargetHandler =
for (auto &i : sectionSymbols) {
         // is not removed in any case
         ELFReference<ELFT> *followOn = nullptr;
         if (!isCommon && previous_atom) {
           followOn = new (_readerStorage)
               ELFReference<ELFT>(lld::Reference::kindLayoutAfter);
           previous_atom->addReference(followOn);
         }
 
+        // If the linker finds that a section has global atoms that are in a 
+        // mergeable section, treat them as defined atoms 
+        int64_t sectionFlags = 0;
+        if (section)
+          sectionFlags = section->sh_flags;
+        sectionFlags &= ~llvm::ELF::SHF_ALLOC;
+        if (doStringsMerge && section && (section->sh_entsize < 2) &&
+            (sectionFlags == (llvm::ELF::SHF_MERGE | llvm::ELF::SHF_STRINGS))) {
+          if ((*si)->getBinding() == llvm::ELF::STB_GLOBAL) {
+            auto definedMergeAtom = new (_readerStorage) ELFDefinedAtom<ELFT>(
+                *this, symbolName, sectionName, (*si), section, symbolData,
+                _references.size(), _references.size(), _references);
+            _definedAtoms._atoms.push_back(definedMergeAtom);
+          }
+          continue;
+        }
+
         auto newAtom = createDefinedAtomAndAssignRelocations(
             symbolName, sectionName, *si, i.first, symbolData);
 
         // If we are inserting a followOn reference, lets add a precededBy 
         // reference too
         if (followOn) {
           ELFReference<ELFT> *precededby = nullptr;
           followOn->setTarget(newAtom);
for (auto &ri : _references) {
         if (shdr)
           sectionFlags = shdr->sh_flags;
         sectionFlags &= ~llvm::ELF::SHF_ALLOC;
 
         // If the section has mergeable strings, then make the relocation
         // refer to the MergeAtom to allow deduping
         if (doStringsMerge && shdr && (shdr->sh_entsize < 2) &&
             (sectionFlags == (llvm::ELF::SHF_MERGE | llvm::ELF::SHF_STRINGS))) {
-          const MergeSectionKey ms(shdr, ri->addend());
+          const TargetRelocationHandler<ELFT> &relHandler = _elfTargetInfo
+              .template getTargetHandler<ELFT>().getRelocationHandler();
+          int64_t fixAddend = relHandler.fixupAddend(*ri);
+          uint64_t addend = ri->addend() + fixAddend;
+          const MergeSectionKey ms(shdr, addend);
           if (_mergedSectionMap.find(ms) == _mergedSectionMap.end()) {
-            uint64_t addend = ri->addend();
             if (Symbol->getType() != llvm::ELF::STT_SECTION)
-              addend = Symbol->st_value + ri->addend();
+              addend = Symbol->st_value + addend;
             MergeAtomsIter mai = findMergeAtom(shdr, addend);
             if (mai != _mergeAtoms.end()) {
               ri->setOffset(addend - ((*mai)->offset()));
               ri->setAddend(0);
               ri->setTarget(*mai);
             } // check
                 else
               llvm_unreachable("unable to find a merge atom");

lib/ReaderWriter/ELF/TargetHandler.h

 #include "llvm/Support/FileOutputBuffer.h"
 
 #include <memory>
 #include <vector>
 
 namespace lld {
 namespace elf {
 template <class ELFT> class ELFDefinedAtom;
+template <class ELFT> class ELFReference;
 class ELFWriter;
 template <class ELFT> class Header;
 template <class ELFT> class Section;
 template <class ELFT> class TargetLayout;
 
 /// \brief The target registers a set of handlers for overriding target specific
 /// attributes for a DefinedAtom. The Reader uses this class to query for the
 /// type of atom and its permissions 
 template <class ELFT> class TargetAtomHandler {
 public:
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
 
   virtual DefinedAtom::ContentType contentType(
       const ELFDefinedAtom<ELFT> *atom) const {
     return atom->contentType();
   }
 
   virtual DefinedAtom::ContentType contentType(const Elf_Sym *sym) const {
     return DefinedAtom::typeZeroFill;
   }
 
-  virtual DefinedAtom::ContentPermissions contentPermissions(
-      const ELFDefinedAtom<ELFT> *atom) const {
+  virtual DefinedAtom::ContentPermissions
+  contentPermissions(const ELFDefinedAtom<ELFT> *atom) const {
     return atom->permissions();
   }
+
 };
 
 template <class ELFT> class TargetRelocationHandler {
 public:
-  virtual ErrorOr<void> applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
-                                        const AtomLayout &,
-                                        const Reference &)const = 0;
+  virtual ErrorOr<void>
+  applyRelocation(ELFWriter &, llvm::FileOutputBuffer &, const AtomLayout &,
+
+  virtual int64_t fixupAddend(const Reference &)const { return 0; }
 };
 
 /// \brief An interface to override functions that are provided by the 
 /// the default ELF Layout
 template <class ELFT> class TargetHandler : public TargetHandlerBase {
 
 public:
   TargetHandler(ELFTargetInfo &targetInfo) : _targetInfo(targetInfo) {}

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h

 class X86_64TargetInfo;
 
 class X86_64TargetRelocationHandler LLVM_FINAL
     : public TargetRelocationHandler<X86_64ELFType> {
 public:
   X86_64TargetRelocationHandler(const X86_64TargetInfo &ti)
       : _tlsSize(0), _targetInfo(ti) {}
 
-  virtual ErrorOr<void> applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
-                                        const AtomLayout &,
-                                        const Reference &)const;
+  virtual ErrorOr<void>
+  applyRelocation(ELFWriter &, llvm::FileOutputBuffer &, const AtomLayout &,
 
+  virtual int64_t fixupAddend(const Reference &)const;
+
 private:
   // Cached size of the TLS segment.
   mutable uint64_t _tlsSize;
   const X86_64TargetInfo &_targetInfo;
 };
 
 class X86_64TargetHandler LLVM_FINAL
     : public DefaultTargetHandler<X86_64ELFType> {

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp

 void reloc32S(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   *reinterpret_cast<llvm::support::little32_t *>(location) = result |
             (int32_t)*reinterpret_cast<llvm::support::little32_t *>(location);
   // TODO: Make sure that the result sign extends to the 64bit value.
 }
 } // end anon namespace
 
+int64_t X86_64TargetRelocationHandler::fixupAddend(const Reference &ref) const {
+  switch (ref.kind()) {
+  case R_X86_64_PC32:
+    return 4;
+  default:
+    return 0;
+  }
+  return 0;
+}
+
 ErrorOr<void> X86_64TargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());
   uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom();
 

test/elf/Inputs/globalconst.c

+/* compile the code with -fmerge-all-constants */
+const char mystr[] = "foobar";

test/elf/mergeglobalatoms.objtxt

+# ELF files can have mergeable strings which are global!, treat them as global
+# defined atoms
+RUN: lld-core -merge-strings=true -reader ELF %p/Inputs/globalconst.o.x86-64 | FileCheck -check-prefix=globalatoms %s
+
+globalatoms:  - name:            mystr
+globalatoms:    scope:           global
+globalatoms:    type:            constant
+globalatoms:    content:         [ 66, 6F, 6F, 62, 61, 72, 00 ]
+globalatoms:    section-choice:  custom-required
+globalatoms:    section-name:    .rodata.str1.1