ELF: Add a standard method for unknown relocation errors

[wnewton]

Summary

At present each TargetRelocationHandler generates a pretty similar error
string and calls llvm_unreachable() when encountering an unknown
relocation. This is not ideal for two reasons:

1. llvm_unreachable disappears in release builds but we still want to know if we encountered a relocation we couldn't handle in release builds.

2. Duplication is bad - there is no need to have a per-architecture error message.

This change adds a test for AArch64 to test whether or not the error
message actually works. The other architectures have not been tested
but they compile and check-lld passes.

[atanasyan]

Good idea. Did you consider to factor out the unhandledReferenceType method into the separate class? Some sort of Diagnostic. The LinkingContext might have a reference to this class. That allow us to keep all diagnostics stuff together and simplify implementation of feature-rich diagnostics engine in the future.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.h

24

Are these lines clang-formatted?

[shankarke]

Please clang-format the change.

[wnewton]

In D6523#6, @atanasyan wrote:

Good idea. Did you consider to factor out the unhandledReferenceType method into the separate class? Some sort of Diagnostic. The LinkingContext might have a reference to this class. That allow us to keep all diagnostics stuff together and simplify implementation of feature-rich diagnostics engine in the future.

I noticed that there is the issue of diagnostics to be resolved on the projects list. It is something that should be done I think but at the moment I am not sure I know what it would look like an dhopefully this change can be an incremental step that work easier in future.

I found a couple of bugs in cc-mode that were causing the indentation to be wrong. Hopefully these are all now fixed.

[atanasyan]

LGTM

[wnewton]

This change has been committed.

r223782 | wnewton | 2014-12-09 16:29:39 +0000 (Tue, 09 Dec 2014) | 17 lines

ELF: Add a standard method for unknown relocation errors

At present each TargetRelocationHandler generates a pretty similar error
string and calls llvm_unreachable() when encountering an unknown
relocation. This is not ideal for two reasons:

1. llvm_unreachable disappears in release builds but we still want to know if we encountered a relocation we couldn't handle in release builds.

2. Duplication is bad - there is no need to have a per-architecture error message.

This change adds a test for AArch64 to test whether or not the error
message actually works. The other architectures have not been tested
but they compile and check-lld passes.

lib/ReaderWriter/ELF/AArch64/AArch64RelocationHandler.h

 namespace elf {
 typedef llvm::object::ELFType<llvm::support::little, 2, true> AArch64ELFType;
 
 template <class ELFT> class AArch64TargetLayout;
 
 class AArch64TargetRelocationHandler final
     : public TargetRelocationHandler<AArch64ELFType> {
 public:
-  AArch64TargetRelocationHandler() {}
+  using TargetRelocationHandler<AArch64ELFType>::TargetRelocationHandler;
 
   std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                   const lld::AtomLayout &,
                                   const Reference &) const override;
 
   static const Registry::KindStrings kindStrings[];
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // AArch64_RELOCATION_HANDLER_H

lib/ReaderWriter/ELF/AArch64/AArch64RelocationHandler.cpp

std::error_code AArch64TargetRelocationHandler::applyRelocation(
   case R_AARCH64_TLSLE_ADD_TPREL_HI12:
     relocR_AARCH64_TLSLE_ADD_TPREL_HI12(location, relocVAddress, targetVAddress,
                                         ref.addend());
     break;
   case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
     relocR_AARCH64_TLSLE_ADD_TPREL_LO12_NC(location, relocVAddress,
                                            targetVAddress, ref.addend());
     break;
-  default: {
-    std::string str;
-    llvm::raw_string_ostream s(str);
-    s << "Unhandled relocation: " << atom._atom->file().path() << ":"
-      << atom._atom->name() << "@" << ref.offsetInAtom() << " "
-      << "#" << ref.kindValue();
-    s.flush();
-    llvm_unreachable(str.c_str());
-  }
+  default:
+    unhandledReferenceType(*atom._atom, ref);
   }
 
   return std::error_code();
 }

lib/ReaderWriter/ELF/AArch64/AArch64RelocationPass.cpp

case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
       static_cast<Derived *>(this)->handlePlain(ref);
       break;
     case R_AARCH64_ADR_GOT_PAGE:
     case R_AARCH64_LD64_GOT_LO12_NC:
     case R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
     case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
       static_cast<Derived *>(this)->handleGOT(ref);
       break;
-    default:
-      llvm_unreachable("Unhandled type in handleReference");
     }
   }
 
 protected:
   /// \brief get the PLT entry for a given IFUNC Atom.
   ///
   /// If the entry does not exist. Both the GOT and PLT entry is created.
   const PLTAtom *getIFUNCPLTEntry(const DefinedAtom *da) {

lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp

 
 using namespace lld;
 using namespace elf;
 
 AArch64TargetHandler::AArch64TargetHandler(AArch64LinkingContext &context)
     : DefaultTargetHandler(context), _context(context),
       _AArch64TargetLayout(new AArch64TargetLayout<AArch64ELFType>(context)),
       _AArch64RelocationHandler(
-          new AArch64TargetRelocationHandler()) {}
+          new AArch64TargetRelocationHandler(context)) {}
 
 void AArch64TargetHandler::registerRelocationNames(Registry &registry) {
   registry.addKindTable(Reference::KindNamespace::ELF,
                         Reference::KindArch::AArch64, kindStrings);
 }
 
 std::unique_ptr<Writer> AArch64TargetHandler::getWriter() {
   switch (this->_context.getOutputELFType()) {

lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.h

 namespace lld {
 namespace elf {
 
 class HexagonTargetHandler;
 
 class HexagonTargetRelocationHandler final :
     public TargetRelocationHandler<HexagonELFType> {
 public:
-  HexagonTargetRelocationHandler(HexagonTargetLayout<HexagonELFType> &layout)
-      : _hexagonTargetLayout(layout) {}
+  HexagonTargetRelocationHandler(HexagonTargetLayout<HexagonELFType> &layout,
+                                 ELFLinkingContext &targetInfo)
+    : TargetRelocationHandler<HexagonELFType>(targetInfo),
+    _hexagonTargetLayout(layout) {}
 
   std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                   const lld::AtomLayout &,
                                   const Reference &) const override;
 
 private:
   HexagonTargetLayout<HexagonELFType> &_hexagonTargetLayout;
 };
 } // elf
 } // lld
 #endif

lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp

relocHexGOTRELSigned(location, relocVAddress, targetVAddress, ref.addend(),
                          _hexagonTargetLayout.getGOTSymAddr(), 6);
     break;
   case R_HEX_GOTREL_16_X:
   case R_HEX_GOTREL_11_X:
     relocHexGOTRELUnsigned(location, relocVAddress, targetVAddress,
                            ref.addend(), _hexagonTargetLayout.getGOTSymAddr());
     break;
 
-  default : {
-    std::string str;
-    llvm::raw_string_ostream s(str);
-    s << "Unhandled Hexagon relocation: #" << ref.kindValue();
-    s.flush();
-    llvm_unreachable(str.c_str());
-  }
+  default:
+    unhandledReferenceType(*atom._atom, ref);
   }
 
   return std::error_code();
 }
 
 

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp

 
 using llvm::makeArrayRef;
 
 HexagonTargetHandler::HexagonTargetHandler(HexagonLinkingContext &context)
     : DefaultTargetHandler(context), _hexagonLinkingContext(context),
       _hexagonRuntimeFile(new HexagonRuntimeFile<HexagonELFType>(context)),
       _hexagonTargetLayout(new HexagonTargetLayout<HexagonELFType>(context)),
       _hexagonRelocationHandler(
-          new HexagonTargetRelocationHandler(*_hexagonTargetLayout.get())) {}
+        new HexagonTargetRelocationHandler(*_hexagonTargetLayout.get(),
+                                           context)) {}
 
 std::unique_ptr<Writer> HexagonTargetHandler::getWriter() {
   switch (_hexagonLinkingContext.getOutputELFType()) {
   case llvm::ELF::ET_EXEC:
     return std::unique_ptr<Writer>(
         new elf::HexagonExecutableWriter<HexagonELFType>(
             _hexagonLinkingContext, *_hexagonTargetLayout.get()));
   case llvm::ELF::ET_DYN:

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.h

 namespace lld {
 namespace elf {
 
 class MipsTargetHandler;
 
 class MipsTargetRelocationHandler final
     : public TargetRelocationHandler<Mips32ElELFType> {
 public:
-  MipsTargetRelocationHandler(MipsTargetLayout<Mips32ElELFType> &layout)
-      : _mipsTargetLayout(layout) {}
+  MipsTargetRelocationHandler(MipsTargetLayout<Mips32ElELFType> &layout,
+                              ELFLinkingContext &targetInfo)
+    : TargetRelocationHandler<Mips32ElELFType>(targetInfo),
+    _mipsTargetLayout(layout) {}
 
   std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                   const lld::AtomLayout &,
                                   const Reference &) const override;
 
 private:
   MipsTargetLayout<Mips32ElELFType> &_mipsTargetLayout;
 };
 
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

case LLD_R_MIPS_HI16:
     relocHi16(ins, 0, targetVAddress, 0, false);
     break;
   case LLD_R_MIPS_LO16:
     relocLo16(ins, 0, targetVAddress, 0, false);
     break;
   case LLD_R_MIPS_STO_PLT:
     // Do nothing.
     break;
-  default: {
-    std::string str;
-    llvm::raw_string_ostream s(str);
-    s << "Unhandled Mips relocation: " << ref.kindValue();
-    llvm_unreachable(s.str().c_str());
-  }
+  default:
+    unhandledReferenceType(*atom._atom, ref);
   }
 
   endian::write<uint32_t, little, 2>(location, ins);
   return std::error_code();
 }

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp

 using namespace elf;
 
 typedef llvm::object::ELFType<llvm::support::little, 2, false> Mips32ElELFType;
 
 MipsTargetHandler::MipsTargetHandler(MipsLinkingContext &ctx)
     : DefaultTargetHandler(ctx), _ctx(ctx),
       _runtimeFile(new MipsRuntimeFile<Mips32ElELFType>(ctx)),
       _targetLayout(new MipsTargetLayout<Mips32ElELFType>(ctx)),
-      _relocationHandler(new MipsTargetRelocationHandler(*_targetLayout)) {}
+      _relocationHandler(new MipsTargetRelocationHandler(*_targetLayout, ctx)) {}
 
 std::unique_ptr<Writer> MipsTargetHandler::getWriter() {
   switch (_ctx.getOutputELFType()) {
   case llvm::ELF::ET_EXEC:
     return std::unique_ptr<Writer>(new MipsExecutableWriter<Mips32ElELFType>(
         _ctx, *_targetLayout, _elfFlagsMerger));
   case llvm::ELF::ET_DYN:
     return std::unique_ptr<Writer>(

lib/ReaderWriter/ELF/PPC/PPCTargetHandler.h

 template <class ELFT> class PPCTargetLayout : public TargetLayout<ELFT> {
 public:
   PPCTargetLayout(PPCLinkingContext &context) : TargetLayout<ELFT>(context) {}
 };
 
 class PPCTargetRelocationHandler final
     : public TargetRelocationHandler<PPCELFType> {
 public:
-  PPCTargetRelocationHandler(PPCLinkingContext &context,
+  PPCTargetRelocationHandler(ELFLinkingContext &context,
                              PPCTargetLayout<PPCELFType> &layout)
-      : _ppcContext(context), _ppcTargetLayout(layout) {}
+      : TargetRelocationHandler<PPCELFType>(context), 
+    _ppcTargetLayout(layout) {}
 
   virtual std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                           const lld::AtomLayout &,
                                           const Reference &) const override;
 
 protected:
-  PPCLinkingContext &_ppcContext;
   PPCTargetLayout<PPCELFType> &_ppcTargetLayout;
 };
 
 class PPCTargetHandler final
     : public DefaultTargetHandler<PPCELFType> {
 public:
   PPCTargetHandler(PPCLinkingContext &context);
 

lib/ReaderWriter/ELF/PPC/PPCTargetHandler.cpp

std::error_code PPCTargetRelocationHandler::applyRelocation(
   if (ref.kindNamespace() != Reference::KindNamespace::ELF)
     return std::error_code();
   assert(ref.kindArch() == Reference::KindArch::PowerPC);
   switch (ref.kindValue()) {
   case R_PPC_REL24:
     relocB24PCREL(location, relocVAddress, targetVAddress, ref.addend());
     break;
 
-  default : {
-    std::string str;
-    llvm::raw_string_ostream s(str);
-    s << "Unhandled PowerPC relocation: #" << ref.kindValue();
-    s.flush();
-    llvm_unreachable(str.c_str());
-  }
+  default:
+    unhandledReferenceType(*atom._atom, ref);
   }
 
   return std::error_code();
 }
 
 PPCTargetHandler::PPCTargetHandler(PPCLinkingContext &context)
     : DefaultTargetHandler(context), _ppcLinkingContext(context),
       _ppcTargetLayout(new PPCTargetLayout<PPCELFType>(context)),

lib/ReaderWriter/ELF/TargetHandler.h

 /// behaivor.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_ELF_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_TARGET_HANDLER_H
 
 #include "Layout.h"
+#include "lld/Core/Atom.h"
 #include "lld/Core/LLVM.h"
 #include "lld/Core/LinkingContext.h"
 #include "lld/Core/STDExtras.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include <memory>
 #include <vector>
 
 namespace lld {
 namespace elf {
 template <class ELFT> class DynamicTable;
 template <class ELFT> class DynamicSymbolTable;
 template <class ELFT> class ELFDefinedAtom;
 template <class ELFT> class ELFReference;
 class ELFWriter;
 template <class ELFT> class ELFHeader;
 template <class ELFT> class Section;
 template <class ELFT> class TargetLayout;
 
 template <class ELFT> class TargetRelocationHandler {
 public:
+  /// Constructor
+  TargetRelocationHandler(ELFLinkingContext &targetInfo)
+    : _context(targetInfo) {}
+
   virtual std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                           const lld::AtomLayout &,
                                           const Reference &) const = 0;
 
+  void unhandledReferenceType(const Atom &atom, const Reference &ref) const {
+    llvm::errs() << "Unhandled reference type in file " << atom.file().path()
+                 << ": reference from " << atom.name() << "+"
+                 << ref.offsetInAtom() << " to " << ref.target()->name()
+                 << "+" << ref.addend() << " of type ";
+
+    StringRef kindValStr;
+    if (!_context.registry().referenceKindToString(ref.kindNamespace(),
+                                                   ref.kindArch(),
+                                                   ref.kindValue(),
+                                                   kindValStr)) {
+      kindValStr = "unknown";
+    }
+
+    llvm::errs() << ref.kindValue() << " (" << kindValStr << ")\n";
+    llvm::report_fatal_error("unhandled reference type");
+  }
+
   virtual ~TargetRelocationHandler() {}
+private:
+  ELFLinkingContext &_context;
 };
 
 /// \brief TargetHandler contains all the information responsible to handle a
 /// a particular target on ELF. A target might wish to override implementation
 /// of creating atoms and how the atoms are written to the output file.
 template <class ELFT> class TargetHandler : public TargetHandlerBase {
 
 public:

lib/ReaderWriter/ELF/X86/X86RelocationHandler.h

 namespace lld {
 namespace elf {
 template <class ELFT> class X86TargetLayout;
 typedef llvm::object::ELFType<llvm::support::little, 2, false> X86ELFType;
 
 class X86TargetRelocationHandler final
     : public TargetRelocationHandler<X86ELFType> {
 public:
-  X86TargetRelocationHandler(X86TargetLayout<X86ELFType> &) {}
+  using TargetRelocationHandler<X86ELFType>::TargetRelocationHandler;
 
   std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                   const lld::AtomLayout &,
                                   const Reference &) const override;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // X86_X86_RELOCATION_HANDLER_H

lib/ReaderWriter/ELF/X86/X86RelocationHandler.cpp

std::error_code X86TargetRelocationHandler::applyRelocation(
   assert(ref.kindArch() == Reference::KindArch::x86);
   switch (ref.kindValue()) {
   case R_386_32:
     reloc32(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_386_PC32:
     relocPC32(location, relocVAddress, targetVAddress, ref.addend());
     break;
-  default: {
-    std::string str;
-    llvm::raw_string_ostream s(str);
-    s << "Unhandled I386 relocation # " << ref.kindValue();
-    s.flush();
-    llvm_unreachable(str.c_str());
-  }
+  default:
+    unhandledReferenceType(*atom._atom, ref);
   }
 
   return std::error_code();
 }

lib/ReaderWriter/ELF/X86/X86TargetHandler.cpp

void X86TargetHandler::registerRelocationNames(Registry &registry) {
   registry.addKindTable(Reference::KindNamespace::ELF, Reference::KindArch::x86,
                         kindStrings);
 }
 
 X86TargetHandler::X86TargetHandler(X86LinkingContext &context)
     : DefaultTargetHandler(context), _x86LinkingContext(context),
       _x86TargetLayout(new X86TargetLayout<X86ELFType>(context)),
       _x86RelocationHandler(
-          new X86TargetRelocationHandler(*_x86TargetLayout.get())) {}
+          new X86TargetRelocationHandler(context)) {}

lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.h

 namespace elf {
 typedef llvm::object::ELFType<llvm::support::little, 2, true> X86_64ELFType;
 
 template <class ELFT> class X86_64TargetLayout;
 
 class X86_64TargetRelocationHandler final
     : public TargetRelocationHandler<X86_64ELFType> {
 public:
-  X86_64TargetRelocationHandler(X86_64TargetLayout<X86_64ELFType> &layout)
-      : _tlsSize(0), _x86_64Layout(layout) {}
+  X86_64TargetRelocationHandler(X86_64TargetLayout<X86_64ELFType> &layout,
+                                ELFLinkingContext &targetInfo)
+    : TargetRelocationHandler<X86_64ELFType>(targetInfo),
+    _tlsSize(0), _x86_64Layout(layout) {}
 
   std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                   const lld::AtomLayout &,
                                   const Reference &) const override;
 
 private:
   // Cached size of the TLS segment.
   mutable uint64_t _tlsSize;
   X86_64TargetLayout<X86_64ELFType> &_x86_64Layout;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // X86_64_RELOCATION_HANDLER_H

lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.cpp

std::error_code X86_64TargetRelocationHandler::applyRelocation(
   // Runtime only relocations. Ignore here.
   case R_X86_64_RELATIVE:
   case R_X86_64_IRELATIVE:
   case R_X86_64_JUMP_SLOT:
   case R_X86_64_GLOB_DAT:
   case R_X86_64_DTPMOD64:
   case R_X86_64_DTPOFF64:
     break;
-  default: {
-    std::string str;
-    llvm::raw_string_ostream s(str);
-    s << "Unhandled relocation: " << atom._atom->file().path() << ":"
-      << atom._atom->name() << "@" << ref.offsetInAtom() << " "
-      << "#" << ref.kindValue();
-    s.flush();
-    llvm_unreachable(str.c_str());
-  }
+  default:
+    unhandledReferenceType(*atom._atom, ref);
   }
 
   return std::error_code();
 }

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp

 
 using namespace lld;
 using namespace elf;
 
 X86_64TargetHandler::X86_64TargetHandler(X86_64LinkingContext &context)
     : DefaultTargetHandler(context), _context(context),
       _x86_64TargetLayout(new X86_64TargetLayout<X86_64ELFType>(context)),
       _x86_64RelocationHandler(
-          new X86_64TargetRelocationHandler(*_x86_64TargetLayout.get())) {}
+        new X86_64TargetRelocationHandler(*_x86_64TargetLayout.get(),
+                                          context)) {}
 
 void X86_64TargetHandler::registerRelocationNames(Registry &registry) {
   registry.addKindTable(Reference::KindNamespace::ELF,
                         Reference::KindArch::x86_64, kindStrings);
 }
 
 std::unique_ptr<Writer> X86_64TargetHandler::getWriter() {
   switch (this->_context.getOutputELFType()) {

test/elf/AArch64/rel-bad.test

+# Check handling of a bad relocation (in this case dynamic in a static object).
+# RUN: yaml2obj -format=elf %s > %t-obj
+# RUN: not lld -flavor gnu -target arm64 -o %t-exe %t-obj 2>&1 | FileCheck %s
+
+# CHECK: Unhandled reference type in file {{.*}}: reference from data1+4 to data1+0 of type 1024 (R_AARCH64_COPY)
+
+!ELF
+FileHeader: !FileHeader
+  Class: ELFCLASS64
+  Data: ELFDATA2LSB
+  Type: ET_REL
+  Machine: EM_AARCH64
+
+Sections:
+- Name: .text
+  Type: SHT_PROGBITS
+  Content: "00000000"
+  AddressAlign: 16
+  Flags: [SHF_ALLOC, SHF_EXECINSTR]
+- Name: .data
+  Type: SHT_PROGBITS
+  Content: "0000000000000000"
+  AddressAlign: 16
+  Flags: [SHF_ALLOC, SHF_WRITE]
+
+- Name: .rela.data
+  Type: SHT_RELA
+  Info: .data
+  AddressAlign: 8
+  Relocations:
+    - Offset: 0x4
+      Symbol: data1
+      Type: R_AARCH64_COPY
+      Addend: 0
+
+Symbols:
+  Global:
+    - Name: _start
+      Section: .text
+      Value: 0x0
+      Size: 4
+    - Name: data1
+      Section: .data
+      Size: 8