[ELF] Add skeleton for X86-64 relocations.

llvm-svn: 171578

lld/lib/ReaderWriter/ELF/CMakeLists.txt

@@ -1,11 +1,12 @@
 add_lld_library(lldELF
-  ReaderELF.cpp
-  WriterELF.cpp
-  ReferenceKinds.cpp
   HexagonReference.cpp
   PPCReference.cpp
-  X86Reference.cpp
+  ReaderELF.cpp
+  ReferenceKinds.cpp
+  WriterELF.cpp
   WriterOptionsELF.cpp
+  X86Reference.cpp
+  X86_64Reference.cpp
   )
 
 target_link_libraries(lldELF

lld/lib/ReaderWriter/ELF/ReferenceKinds.cpp

@@ -30,6 +30,8 @@ KindHandler::makeHandler(uint16_t arch, llvm::support::endianness endian) {
     return std::unique_ptr<KindHandler>(new HexagonKindHandler());
   case llvm::ELF::EM_386:
     return std::unique_ptr<KindHandler>(new X86KindHandler());
+  case llvm::ELF::EM_X86_64:
+    return std::unique_ptr<KindHandler>(new X86_64KindHandler());
   case llvm::ELF::EM_PPC:
     return std::unique_ptr<KindHandler>(new PPCKindHandler(endian));
   default:

lld/lib/ReaderWriter/ELF/ReferenceKinds.h

@@ -115,6 +115,34 @@ private:
                       uint64_t targetAddress, uint64_t addend)> > _fixupHandler;
 };
 
+class X86_64KindHandler : public KindHandler {
+public:
+  enum Kinds {
+    invalid, // used to denote an error creating a Reference
+    none,
+  };
+
+  enum RelocationError {
+    NoError,
+  };
+
+  virtual ~X86_64KindHandler();
+  X86_64KindHandler();
+  virtual Kind stringToKind(StringRef str);
+  virtual StringRef kindToString(Kind);
+  virtual bool isCallSite(Kind);
+  virtual bool isPointer(Kind);
+  virtual bool isLazyImmediate(Kind);
+  virtual bool isLazyTarget(Kind);
+  virtual void applyFixup(int32_t reloc, uint64_t addend, uint8_t *location,
+                          uint64_t fixupAddress, uint64_t targetAddress);
+
+private:
+  llvm::DenseMap<int32_t,
+           std::function<int (uint8_t *location, uint64_t fixupAddress,
+                      uint64_t targetAddress, uint64_t addend)> > _fixupHandler;
+};
+
 class PPCKindHandler : public KindHandler {
 public:
   enum Kinds {

lld/lib/ReaderWriter/ELF/X86_64Reference.cpp

@@ -0,0 +1,69 @@
+//===- lib/ReaderWriter/ELF/X86_64Reference.cpp ---------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ReferenceKinds.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
+
+#include "llvm/Support/ELF.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace lld {
+namespace elf {
+X86_64KindHandler::X86_64KindHandler(){
+}
+
+X86_64KindHandler::~X86_64KindHandler() {
+}
+
+Reference::Kind X86_64KindHandler::stringToKind(StringRef str) {
+  return llvm::StringSwitch<Reference::Kind>(str)
+    .Case("none", none)
+    .Default(invalid);
+}
+
+StringRef X86_64KindHandler::kindToString(Reference::Kind kind) {
+  switch ((int32_t)kind) {
+  default:
+    return "none";
+  }
+}
+
+bool X86_64KindHandler::isCallSite(Kind kind) {
+  llvm_unreachable("Unimplemented: X86KindHandler::isCallSite");
+  return false;
+}
+
+bool X86_64KindHandler::isPointer(Kind kind) {
+  llvm_unreachable("Unimplemented: X86KindHandler::isPointer");
+  return false;
+}
+
+bool X86_64KindHandler::isLazyImmediate(Kind kind) {
+  llvm_unreachable("Unimplemented: X86KindHandler::isLazyImmediate");
+  return false;
+}
+
+bool X86_64KindHandler::isLazyTarget(Kind kind) {
+  llvm_unreachable("Unimplemented: X86KindHandler::isLazyTarget");
+  return false;
+}
+
+void X86_64KindHandler::applyFixup(int32_t reloc, uint64_t addend,
+                                   uint8_t *location, uint64_t fixupAddress,
+                                   uint64_t targetAddress) {
+  if (_fixupHandler[reloc])
+    _fixupHandler[reloc](location, fixupAddress, targetAddress, addend);
+  else
+    llvm_unreachable("Unknown relocation type.");
+}
+} // end namespace elf
+} // end namespace lld

lld/test/elf/x86_64-kinds.test

@@ -0,0 +1 @@
+RUN: lld -flavor core -target x86_64-linux