ELF: Move relocation predicates out of the context class.

[ruiu]

Summary

Looks like each subdirectory in ELF directory was created as a copy of
some architecture (x86_64 perhaps?) as a template. They contain many
similar-looking code. They are not always identical since they diverged
over time. Some differences between the subdirectories are real, and
some are not but just different.

A patch for ELF often has to update multiple occurrences of
similar-looking code in the subdirectories. r228905 is an example.
This is not a good shape. It's probably time to visit all subdirectories,
and if there's architecture-independent stuff there, move that to the
ELF parent directory.

This patch is a starter. This is not totally architecture-independent
since relocations depend on architecture types, but this reduces the
amount of code from the subdirectories and also cut dependencies between
code, so I think it's not bad as a starter. After submitting this,
we have less code there, which makes it easier to find code duplicates.

We have bunch of predicates for relocations for questions like "is
this relocation is for PLT?" We can say whether a relocation is a PLT
or not, for example, by just looking at the relocation. Currently the
predicates are members of LinkingContext, but no context is needed to
answer to that question. And in general if we can make the same decision
by looking at not both X and Y but only X, the latter is preferred.

It is now clear that some architectures didn't define some predicates.
For example, x86 didn't have a predicate function for the copy relocation.
I think this is a missing feature, we may want to revisit that later.

By moving the code out of LinkingContext, each <arch>LinkingContext
becomes smaller, which helps find duplicates in the subdirectories.

[ruiu]

I'd like to add a note that, like r227784, using vtable for dispatching is not always a win, if there's anyone who doesn't like the switch statements.

[atanasyan]

I am sorry, but I do not see how this patch helps to reduce code duplication. I think commit rL222313 is a good example of sharing a common ELF code among targets. In that case Shankar found the code applicable to all ELF target and relocated them to the base class DefaultLayout. In this patch we just replace virtual functions by switch cases.

[• shankar.easwaran]

Please don't move architecture specific code to common code.

I don't see a need of doing this right now.

Bigcheese?

[shankarke]

other reasons I dont like this design is

• IMO, this would become hard to maintain and not clean.
• Checks all architecture specific relocations in one common place, it would hurt performance.
  • For example, if x86_64 is the current link type, the case checks for all other architectures, and this happens for every relocation.

A good alternative is to move this code to the TargetHandler, as its specific to only that target.

What do you think ? Simon / Bigcheese ?

[atanasyan]

I think all target related code should be separated by LinkingContext, TargetHandler etc descendant classes. If moving relocation predicates to the TargetHandler descendants makes the code clear, it is a good idea.

[ruiu]

But the relocation type is not architecture dependent, right? The
relocation itself knows what the relocation type of itself is. Maybe I can
make this member functions of relocation, but adding that predicates to
linking context object is not logically correct.

[shankarke]

relocation types are very much architecture dependent, thats why they are handled in each architecture/target. Its ok to move this to the TargetHandler, and the code would be more clear.

[ruiu]

Shankar,

Are you saying that a relocation type cannot be interpreted if we don't
have a prior knowledge what machine type the reference is? It is true that
relocation types are machine dependent, of course, but that's different
from what I'm trying to do here.

We are currently passing a reference to a linking context object to ask
"what this reference type is?" But as I wrote before the reference itself
has the machine type info, so we don't have to involve the linking context.
The function to get the reference type can be an independent function, or a
member function of the reference, but the linking context is a wrong place,
because it's not related to the context.

[shankarke]

I do agree that LinkingContext is not the place to have these functions defined. Moving this to lld::Reference is not the right thing to do IMO as its a base class for all references. We do have TargetHandler for this purpose where each target would override this functionality.

[ruiu]

As the same reason they don't belong to the linking context, they don't
belong to the target handler too. The predicates for relocations don't need
any knowledge on a target and will never be overridden depending on
architecture. They are just independent predicates on references.

I think I read about this in Effective C++ and that's a good practice -- if
your functionality uses only public interface of other classes, making it a
non-member function is preferred. By doing that it cuts dependencies and it
also make it obvious that the function doesn't depend on any hidden
information. I believe this is exactly what I'm trying to do in this patch.

[shankarke]

I disagree. This kind of code is commonly placed in the TargetHandler. I was just browsing MachO and mach-o too has these utility functions in the ArchHandler. Myself/Simon do agree that this code pattern when moved to the TargetHandler for ELF/Gnu flavor makes the code much better too.

[rnk]

One thing to consider is, will lld support compiling out different ELF targets to reduce linker size? By using the virtual interface, you can compile out a few switch tables. It may not be worth it, though. For example, you can't compile out MS ABI support from Clang because it's too intertwined with the regular code.

[shankarke]

In addition to what we discussed in this review, that was one of my intention to have a linker to support just a particular ELF target.

[Bigcheese]

I really dislike pulling architecture specific stuff up out of the architecture it belongs to and shoving it all in a single file. I get that it doesn't need the context, but I feel this is a worse solution.

include/lld/ReaderWriter/ELFLinkingContext.h

public:
 
   /// This controls if undefined atoms need to be created for undefines that are
   /// present in a SharedLibrary. If this option is set, undefined atoms are
   /// created for every undefined symbol that are present in the dynamic table
   /// in the shared library
   bool useShlibUndefines() const { return _useShlibUndefines; }
   /// @}
 
-  /// \brief Does this relocation belong in the dynamic relocation table?
-  ///
-  /// This table is evaluated at loadtime by the dynamic loader and is
-  /// referenced by the DT_RELA{,ENT,SZ} entries in the dynamic table.
-  /// Relocations that return true will be added to the dynamic relocation
-  /// table.
-  virtual bool isDynamicRelocation(const Reference &) const { return false; }
-
-  /// \brief Is this a copy relocation?
-  ///
-  /// If this is a copy relocation, its target must be an ObjectAtom. We must
-  /// include in DT_NEEDED the name of the library where this object came from.
-  virtual bool isCopyRelocation(const Reference &) const {
-    return false;
-  }
-
   bool validateImpl(raw_ostream &diagnostics) override;
 
   /// \brief Does the linker allow dynamic libraries to be linked with?
   /// This is true when the output mode of the executable is set to be
   /// having NMAGIC/OMAGIC
   virtual bool allowLinkWithDynamicLibraries() const {
     if (_outputMagic == OutputMagic::NMAGIC ||
         _outputMagic == OutputMagic::OMAGIC || _noAllowDynamicLibraries)
       return false;
     return true;
   }
 
   /// \brief Use Elf_Rela format to output relocation tables.
   virtual bool isRelaOutputFormat() const { return true; }
 
-  /// \brief Does this relocation belong in the dynamic plt relocation table?
-  ///
-  /// This table holds all of the relocations used for delayed symbol binding.
-  /// It will be evaluated at load time if LD_BIND_NOW is set. It is referenced
-  /// by the DT_{JMPREL,PLTRELSZ} entries in the dynamic table.
-  /// Relocations that return true will be added to the dynamic plt relocation
-  /// table.
-  virtual bool isPLTRelocation(const Reference &) const { return false; }
-
   /// \brief The path to the dynamic interpreter
   virtual StringRef getDefaultInterpreter() const {
     return "/lib64/ld-linux-x86-64.so.2";
   }
 
   /// \brief The dynamic linker path set by the --dynamic-linker option
   virtual StringRef getInterpreter() const {
     if (_dynamicLinkerArg)

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.h

public:
 
   void addPasses(PassManager &) override;
 
   uint64_t getBaseAddress() const override {
     if (_baseAddress == 0)
       return 0x400000;
     return _baseAddress;
   }
-
-  bool isDynamicRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::AArch64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_AARCH64_COPY:
-    case llvm::ELF::R_AARCH64_GLOB_DAT:
-    case llvm::ELF::R_AARCH64_RELATIVE:
-    case llvm::ELF::R_AARCH64_TLS_DTPREL64:
-    case llvm::ELF::R_AARCH64_TLS_DTPMOD64:
-    case llvm::ELF::R_AARCH64_TLS_TPREL64:
-    case llvm::ELF::R_AARCH64_TLSDESC:
-    case llvm::ELF::R_AARCH64_IRELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  bool isCopyRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::AArch64);
-    if (r.kindValue() == llvm::ELF::R_AARCH64_COPY)
-      return true;
-    return false;
-  }
-
-  bool isPLTRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::AArch64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_AARCH64_JUMP_SLOT:
-    case llvm::ELF::R_AARCH64_IRELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  bool isRelativeReloc(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::AArch64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_AARCH64_IRELATIVE:
-    case llvm::ELF::R_AARCH64_RELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/Atoms.h

 #include <memory>
 #include <vector>
 
 namespace lld {
 namespace elf {
 template <class ELFT> class DynamicFile;
 template <typename ELFT> class ELFFile;
 
+// Predicates for ELF references.
+bool isDynamicRelocation(const Reference &r);
+bool isCopyRelocation(const Reference &r);
+bool isPLTRelocation(const Reference &r);
+bool isRelativeRelocation(const Reference &r);
+
 /// \brief Relocation References: Defined Atoms may contain references that will
 /// need to be patched before the executable is written.
 ///
 /// Construction of ELFReferences is two pass process. ELFReferences are
 /// instantiated while we are iterating over symbol tables to atomize
 /// symbols. At that time we only know the index of relocation target symbol
 /// (not target atom) about a relocation, so we store the index to
 /// ELFREference. In the second pass, ELFReferences are revisited to update

lib/ReaderWriter/ELF/Atoms.cpp

+//===- lib/ReaderWriter/ELF/Atoms.cpp -------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Atoms.h"
+
+namespace lld {
+namespace elf {
+
+// Returns true if a given relocation belongs in the dynamic relocation table.
+//
+// The relocation table is evaluated at loadtime by the dynamic loader
+// and is referenced by the DT_RELA{,ENT,SZ} entries in the dynamic table.
+// Relocations that return true will be added to the dynamic relocation
+// table.
+bool isDynamicRelocation(const Reference &r) {
+  if (r.kindNamespace() != Reference::KindNamespace::ELF)
+    return false;
+  switch (r.kindArch()) {
+  case Reference::KindArch::AArch64:
+    switch (r.kindValue()) {
+    case llvm::ELF::R_AARCH64_COPY:
+    case llvm::ELF::R_AARCH64_GLOB_DAT:
+    case llvm::ELF::R_AARCH64_RELATIVE:
+    case llvm::ELF::R_AARCH64_TLS_DTPREL64:
+    case llvm::ELF::R_AARCH64_TLS_DTPMOD64:
+    case llvm::ELF::R_AARCH64_TLS_TPREL64:
+    case llvm::ELF::R_AARCH64_TLSDESC:
+    case llvm::ELF::R_AARCH64_IRELATIVE:
+      return true;
+    }
+    return false;
+  case Reference::KindArch::ARM:
+    return false;
+  case Reference::KindArch::Hexagon:
+    switch (r.kindValue()) {
+    case llvm::ELF::R_HEX_RELATIVE:
+    case llvm::ELF::R_HEX_GLOB_DAT:
+      return true;
+    }
+    return false;
+  case Reference::KindArch::Mips:
+    switch (r.kindValue()) {
+    case llvm::ELF::R_MIPS_COPY:
+    case llvm::ELF::R_MIPS_REL32:
+    case llvm::ELF::R_MIPS_TLS_DTPMOD32:
+    case llvm::ELF::R_MIPS_TLS_DTPREL32:
+    case llvm::ELF::R_MIPS_TLS_TPREL32:
+      return true;
+    }
+    return false;
+  case Reference::KindArch::x86:
+    return false;
+  case Reference::KindArch::x86_64:
+    switch (r.kindValue()) {
+    case llvm::ELF::R_X86_64_RELATIVE:
+    case llvm::ELF::R_X86_64_GLOB_DAT:
+    case llvm::ELF::R_X86_64_COPY:
+    case llvm::ELF::R_X86_64_DTPMOD64:
+    case llvm::ELF::R_X86_64_DTPOFF64:
+      return true;
+    }
+    return false;
+  case Reference::KindArch::all:
+    llvm_unreachable("internal error");
+  }
+}
+
+// Returns true if a given reference is a copy relocation.
+//
+// If this is a copy relocation, its target must be an ObjectAtom.
+// We must include in DT_NEEDED the name of the library where this
+// object came from.
+bool isCopyRelocation(const Reference &r) {
+  if (r.kindNamespace() != Reference::KindNamespace::ELF)
+    return false;
+  switch (r.kindArch()) {
+  case Reference::KindArch::AArch64:
+    return r.kindValue() == llvm::ELF::R_AARCH64_COPY;
+  case Reference::KindArch::ARM:
+  case Reference::KindArch::Hexagon:
+    return false;
+  case Reference::KindArch::Mips:
+    return r.kindValue() == llvm::ELF::R_MIPS_COPY;
+  case Reference::KindArch::x86:
+    return false;
+  case Reference::KindArch::x86_64:
+    return r.kindValue() == llvm::ELF::R_X86_64_COPY;
+  case Reference::KindArch::all:
+    llvm_unreachable("internal error");
+  }
+}
+
+// Returns true if a given reference belongs in the dynamic plt relocation
+// table.
+//
+// This table holds all of the relocations used for delayed symbol binding.
+// It will be evaluated at load time if LD_BIND_NOW is set. It is referenced
+// by the DT_{JMPREL,PLTRELSZ} entries in the dynamic table.
+// Relocations that return true will be added to the dynamic plt relocation
+// table.
+bool isPLTRelocation(const Reference &r) {
+  if (r.kindNamespace() != Reference::KindNamespace::ELF)
+    return false;
+  switch (r.kindArch()) {
+  case Reference::KindArch::AArch64:
+    switch (r.kindValue()) {
+    case llvm::ELF::R_AARCH64_JUMP_SLOT:
+    case llvm::ELF::R_AARCH64_IRELATIVE:
+      return true;
+    }
+    return false;
+  case Reference::KindArch::ARM:
+    return false;
+  case Reference::KindArch::Hexagon:
+    return r.kindValue() == llvm::ELF::R_HEX_JMP_SLOT;
+  case Reference::KindArch::Mips:
+    return r.kindValue() == llvm::ELF::R_MIPS_JUMP_SLOT;
+  case Reference::KindArch::x86:
+    return false;
+  case Reference::KindArch::x86_64:
+    switch (r.kindValue()) {
+    case llvm::ELF::R_X86_64_JUMP_SLOT:
+    case llvm::ELF::R_X86_64_IRELATIVE:
+      return true;
+    }
+    return false;
+  case Reference::KindArch::all:
+    llvm_unreachable("internal error");
+  }
+}
+
+// Returns true if a given reference is is a relative relocation.
+bool isRelativeRelocation(const Reference &r) {
+  if (r.kindNamespace() != Reference::KindNamespace::ELF)
+    return false;
+  switch (r.kindArch()) {
+  case Reference::KindArch::AArch64:
+    switch (r.kindValue()) {
+    case llvm::ELF::R_AARCH64_IRELATIVE:
+    case llvm::ELF::R_AARCH64_RELATIVE:
+      return true;
+    }
+    return false;
+  case Reference::KindArch::ARM:
+    return false;
+  case Reference::KindArch::Hexagon:
+    return r.kindValue() == llvm::ELF::R_HEX_RELATIVE;
+  case Reference::KindArch::Mips:
+    return false;
+  case Reference::KindArch::x86:
+    switch (r.kindValue()) {
+    case llvm::ELF::R_386_IRELATIVE:
+    case llvm::ELF::R_386_RELATIVE:
+      return true;
+    }
+    return false;
+  case Reference::KindArch::x86_64:
+    switch (r.kindValue()) {
+    case llvm::ELF::R_X86_64_IRELATIVE:
+    case llvm::ELF::R_X86_64_RELATIVE:
+      return true;
+    }
+    return false;
+  case Reference::KindArch::all:
+    llvm_unreachable("internal error");
+  }
+}
+
+} // end namespace elf
+} // end namespace lld

lib/ReaderWriter/ELF/CMakeLists.txt

 add_llvm_library(lldELF
+  Atoms.cpp
   ELFLinkingContext.cpp
   Reader.cpp
   Writer.cpp
   LINK_LIBS
     lldCore
     lldPasses
     lldYAML
     LLVMSupport

lib/ReaderWriter/ELF/DefaultLayout.h

if (const DefinedAtom *definedAtom = dyn_cast<DefinedAtom>(atom)) {
 
     StringRef sectionName = getInputSectionName(definedAtom);
     AtomSection<ELFT> *section =
         getSection(sectionName, contentType, permissions);
 
     // Add runtime relocations to the .rela section.
     for (const auto &reloc : *definedAtom) {
       bool isLocalReloc = true;
-      if (_context.isDynamicRelocation(*reloc)) {
+      if (isDynamicRelocation(*reloc)) {
         getDynamicRelocationTable()->addRelocation(*definedAtom, *reloc);
         isLocalReloc = false;
-      } else if (_context.isPLTRelocation(*reloc)) {
+      } else if (isPLTRelocation(*reloc)) {
         getPLTRelocationTable()->addRelocation(*definedAtom, *reloc);
         isLocalReloc = false;
       }
 
       if (!reloc->target())
         continue;
 
       //Ignore undefined atoms that are not target of dynamic relocations
       if (isa<UndefinedAtom>(reloc->target()) && isLocalReloc)
         continue;
 
-      if (_context.isCopyRelocation(*reloc)) {
+      if (isCopyRelocation(*reloc)) {
         _copiedDynSymNames.insert(definedAtom->name());
         continue;
       }
 
       _referencedDynAtoms.insert(reloc->target());
     }
 
     return section->appendAtom(atom);

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.h

 typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
 
 class HexagonLinkingContext final : public ELFLinkingContext {
 public:
   static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
   HexagonLinkingContext(llvm::Triple triple);
 
   void addPasses(PassManager &) override;
-
-  bool isDynamicRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    switch (r.kindValue()) {
-    case llvm::ELF::R_HEX_RELATIVE:
-    case llvm::ELF::R_HEX_GLOB_DAT:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  bool isPLTRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    switch (r.kindValue()) {
-    case llvm::ELF::R_HEX_JMP_SLOT:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  /// \brief Hexagon has only one relative relocation
-  /// a) for supporting relative relocs - R_HEX_RELATIVE
-  bool isRelativeReloc(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    switch (r.kindValue()) {
-    case llvm::ELF::R_HEX_RELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

public:
   MipsELFFlagsMerger &getELFFlagsMerger();
 
   // ELFLinkingContext
   uint64_t getBaseAddress() const override;
   StringRef entrySymbolName() const override;
   StringRef getDefaultInterpreter() const override;
   void addPasses(PassManager &pm) override;
   bool isRelaOutputFormat() const override { return false; }
-  bool isDynamicRelocation(const Reference &r) const override;
-  bool isCopyRelocation(const Reference &r) const override;
-  bool isPLTRelocation(const Reference &r) const override;
 
 private:
   MipsELFFlagsMerger _flagsMerger;
 };
 
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

 
 void MipsLinkingContext::addPasses(PassManager &pm) {
   auto pass = createMipsRelocationPass(*this);
   if (pass)
     pm.add(std::move(pass));
   ELFLinkingContext::addPasses(pm);
   pm.add(llvm::make_unique<elf::MipsCtorsOrderPass>());
 }
-
-bool MipsLinkingContext::isDynamicRelocation(const Reference &r) const {
-  if (r.kindNamespace() != Reference::KindNamespace::ELF)
-    return false;
-  assert(r.kindArch() == Reference::KindArch::Mips);
-  switch (r.kindValue()) {
-  case llvm::ELF::R_MIPS_COPY:
-  case llvm::ELF::R_MIPS_REL32:
-  case llvm::ELF::R_MIPS_TLS_DTPMOD32:
-  case llvm::ELF::R_MIPS_TLS_DTPREL32:
-  case llvm::ELF::R_MIPS_TLS_TPREL32:
-    return true;
-  default:
-    return false;
-  }
-}
-
-bool MipsLinkingContext::isCopyRelocation(const Reference &r) const {
-  if (r.kindNamespace() != Reference::KindNamespace::ELF)
-    return false;
-  assert(r.kindArch() == Reference::KindArch::Mips);
-  if (r.kindValue() == llvm::ELF::R_MIPS_COPY)
-    return true;
-  return false;
-}
-
-bool MipsLinkingContext::isPLTRelocation(const Reference &r) const {
-  if (r.kindNamespace() != Reference::KindNamespace::ELF)
-    return false;
-  assert(r.kindArch() == Reference::KindArch::Mips);
-  switch (r.kindValue()) {
-  case llvm::ELF::R_MIPS_JUMP_SLOT:
-    return true;
-  default:
-    return false;
-  }
-}

lib/ReaderWriter/ELF/SectionChunks.h

void writeRela(ELFWriter *writer, Elf_Rela &r, const DefinedAtom &atom,
                  const Reference &ref) {
     uint32_t index =
         _symbolTable ? _symbolTable->getSymbolTableIndex(ref.target())
                      : (uint32_t)STN_UNDEF;
     r.setSymbolAndType(index, ref.kindValue(), false);
     r.r_offset = writer->addressOfAtom(&atom) + ref.offsetInAtom();
     r.r_addend = 0;
     // The addend is used only by relative relocations
-    if (this->_context.isRelativeReloc(ref))
+    if (isRelativeRelocation(ref))
       r.r_addend = writer->addressOfAtom(ref.target()) + ref.addend();
     DEBUG_WITH_TYPE("ELFRelocationTable",
                     llvm::dbgs() << ref.kindValue() << " relocation at "
                                  << atom.name() << "@" << r.r_offset << " to "
                                  << ref.target()->name() << "@" << r.r_addend
                                  << "\n";);
   }
 

lib/ReaderWriter/ELF/X86/X86LinkingContext.h

 #include "llvm/Support/ELF.h"
 
 namespace lld {
 namespace elf {
 class X86LinkingContext final : public ELFLinkingContext {
 public:
   static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
   X86LinkingContext(llvm::Triple);
-
-  /// \brief X86 has only two relative relocation
-  /// a) for supporting IFUNC relocs - R_386_IRELATIVE
-  /// b) for supporting relative relocs - R_386_RELATIVE
-  bool isRelativeReloc(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_386_IRELATIVE:
-    case llvm::ELF::R_386_RELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
 };
 } // end namespace elf
 } // end namespace lld
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.h

public:
 
   void addPasses(PassManager &) override;
 
   uint64_t getBaseAddress() const override {
     if (_baseAddress == 0)
       return 0x400000;
     return _baseAddress;
   }
-
-  bool isDynamicRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86_64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_X86_64_RELATIVE:
-    case llvm::ELF::R_X86_64_GLOB_DAT:
-    case llvm::ELF::R_X86_64_COPY:
-    case llvm::ELF::R_X86_64_DTPMOD64:
-    case llvm::ELF::R_X86_64_DTPOFF64:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  bool isCopyRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86_64);
-    if (r.kindValue() == llvm::ELF::R_X86_64_COPY)
-      return true;
-    return false;
-  }
-
-  virtual bool isPLTRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86_64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_X86_64_JUMP_SLOT:
-    case llvm::ELF::R_X86_64_IRELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  /// \brief X86_64 has two relative relocations
-  /// a) for supporting IFUNC - R_X86_64_IRELATIVE
-  /// b) for supporting relative relocs - R_X86_64_RELATIVE
-  bool isRelativeReloc(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86_64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_X86_64_IRELATIVE:
-    case llvm::ELF::R_X86_64_RELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif