[lld][ELF]: Minimal implementation for ARM static linking

[denis-protivensky]

Summary

The skeleton code for ELF binary generation for ARM platform.

The code is able to statically link the simplest case of int main() { return 0; } sample with only ARM code (no Thumb code, no interwork, -marm, -mno-thumb-interwork options used) and with musl libc built with no interwork and no Thumb code as well.

Note: This is the replacement for http://reviews.llvm.org/D6446

[wnewton]

This looks ok to me.

[ruiu]

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

10

ifdef guard should include the path name.

#ifndef LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.h

35

A name beginning with '_' followed by an uppercase character is reserved to the implementation (just like __), so please don't use such name. s/_ARMTargetLayout/_armTargetLayout/.

lib/ReaderWriter/ELF/ARM/ARMTarget.h

2

Why do we need this almost-empty header? Can't we directly include ARMLinkingContext.h?

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

63

They conflict with reserved names.

[denis-protivensky]

Updated:

• header guard names reflect paths to files
• member variables use lowercase letters right after dash symbol

[ruiu]

LGTM with this change.

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

40

_ARM -> _arm

[denis-protivensky]

Fixed variable spelling.

[atanasyan]

LGTM

[denis-protivensky]

I see everyone has accepted the revision.
How should I merge it as I don't have write permissions in the repo? Can someone help me with this please?

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

10

Good.

40

Fixed.

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.h

35

Good, didn't know about that.

lib/ReaderWriter/ELF/ARM/ARMTarget.h

2

That's how the structure of files is organized.
Targets.h includes platform-specific *Target.h file, and it in turn includes its linking context.

[ruiu]

Please upload your latest revision to Phabricator so that I can submit on
behalf of you.

[denis-protivensky]

Rebased the code to the actual sources.

[denis-protivensky]

Rui, please, merge the code. It's now up-to-date.

[garious]

Hi Denis, I've volunteered to land this patch. Due to the size of the contribution, I'd like to put some extra effort into ensuring that your name ends up in the Author field on the git mirror. If we're able to configure git-svn to do that, I hope we can have it done and this patch landed in the next day or two. If you'd rather see it land today and don't mind my name stamped all over "git blame" output, I can go ahead and pull the trigger immediately. Please let me know your preference.

Also, the member variable _armTargetLayout is unused. If you make more changes before this lands, please delete that variable. Otherwise, I'll take care of it.

Thanks,
Greg

[denis-protivensky]

Hi Greg,

Thanks for taking care of it.
Concerning my name as an author: if it's possible, I'd like to keep my name and wait couple of days before you're done.
Concerning removing extra variable: I didn't plan to make any changes, but I can take care of it shortly.

Thanks,

Denis.

[denis-protivensky]

Removed unused variable.

[garious]

Thanks for your patience. Could you please rebase your change on the latest? r226557 changed the TargetRelocationHandler and removed unhandledReferenceType().

[denis-protivensky]

Fixed after rebase:

• TargetRelocationHandler ctor
• make_unhandled_reloc_error() usage

[denis-protivensky]

Greg, updated. Thanks!

[garious]

Thanks. I'm afraid we won't be able to reassign the author field in the git mirror until the next llvm.org update. I'll go ahead and land this patch now.

[denis-protivensky]

Good.

[garious]

Committed in r226643. Thanks!

docs/open_projects.rst

 .. _open_projects:
 
 Open Projects
 =============
 
 .. include:: ../include/lld/Core/TODO.txt
 .. include:: ../lib/Core/TODO.txt
 .. include:: ../lib/Driver/TODO.rst
 .. include:: ../lib/ReaderWriter/ELF/X86_64/TODO.rst
 .. include:: ../lib/ReaderWriter/ELF/AArch64/TODO.rst
+.. include:: ../lib/ReaderWriter/ELF/ARM/TODO.rst
 .. include:: ../tools/lld/TODO.txt
 
 Documentation TODOs
 ~~~~~~~~~~~~~~~~~~~
 
 .. todolist::

lib/Driver/GnuLdDriver.cpp

getArchType(const llvm::Triple &triple, StringRef value) {
   case llvm::Triple::mipsel:
     if (value == "elf32ltsmip")
       return llvm::Triple::mipsel;
     return llvm::None;
   case llvm::Triple::aarch64:
     if (value == "aarch64linux")
       return llvm::Triple::aarch64;
     return llvm::None;
+  case llvm::Triple::arm:
+    if (value == "armelf_linux_eabi")
+      return llvm::Triple::arm;
+    return llvm::None;
   default:
     return llvm::None;
   }
 }
 
 static bool isLinkerScript(StringRef path, raw_ostream &diag) {
   llvm::sys::fs::file_magic magic = llvm::sys::fs::file_magic::unknown;
   std::error_code ec = getFileMagic(path, magic);

lib/ReaderWriter/ELF/ARM/ARMELFFile.h

+//===--------- lib/ReaderWriter/ELF/ARM/ARMELFFile.h ----------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_READER_WRITER_ELF_ARM_ARM_ELF_FILE_H
+#define LLD_READER_WRITER_ELF_ARM_ARM_ELF_FILE_H
+
+#include "ELFReader.h"
+
+namespace lld {
+namespace elf {
+
+class ARMLinkingContext;
+
+template <class ELFT> class ARMELFFile : public ELFFile<ELFT> {
+public:
+  ARMELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings)
+      : ELFFile<ELFT>(std::move(mb), atomizeStrings) {}
+
+  static ErrorOr<std::unique_ptr<ARMELFFile>>
+  create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
+    return std::unique_ptr<ARMELFFile<ELFT>>(
+        new ARMELFFile<ELFT>(std::move(mb), atomizeStrings));
+  }
+};
+
+template <class ELFT> class ARMDynamicFile : public DynamicFile<ELFT> {
+public:
+  ARMDynamicFile(const ARMLinkingContext &context, StringRef name)
+      : DynamicFile<ELFT>(context, name) {}
+};
+
+} // elf
+} // lld
+
+#endif // LLD_READER_WRITER_ELF_ARM_ARM_ELF_FILE_H

lib/ReaderWriter/ELF/ARM/ARMELFReader.h

+//===--------- lib/ReaderWriter/ELF/ARM/ARMELFReader.h --------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_READER_WRITER_ARM_ARM_ELF_READER_H
+#define LLD_READER_WRITER_ARM_ARM_ELF_READER_H
+
+#include "ARMELFFile.h"
+#include "ELFReader.h"
+
+namespace lld {
+namespace elf {
+
+typedef llvm::object::ELFType<llvm::support::little, 2, false> ARMELFType;
+
+struct ARMDynamicFileCreateELFTraits {
+  typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
+
+  template <class ELFT>
+  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
+                            bool useUndefines) {
+    return lld::elf::ARMDynamicFile<ELFT>::create(std::move(mb), useUndefines);
+  }
+};
+
+struct ARMELFFileCreateELFTraits {
+  typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
+
+  template <class ELFT>
+  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
+                            bool atomizeStrings) {
+    return lld::elf::ARMELFFile<ELFT>::create(std::move(mb), atomizeStrings);
+  }
+};
+
+class ARMELFObjectReader
+    : public ELFObjectReader<ARMELFType, ARMELFFileCreateELFTraits> {
+public:
+  ARMELFObjectReader(bool atomizeStrings)
+      : ELFObjectReader<ARMELFType, ARMELFFileCreateELFTraits>(
+            atomizeStrings, llvm::ELF::EM_ARM) {}
+};
+
+class ARMELFDSOReader
+    : public ELFDSOReader<ARMELFType, ARMDynamicFileCreateELFTraits> {
+public:
+  ARMELFDSOReader(bool useUndefines)
+      : ELFDSOReader<ARMELFType, ARMDynamicFileCreateELFTraits>(
+            useUndefines, llvm::ELF::EM_ARM) {}
+};
+
+} // namespace elf
+} // namespace lld
+
+#endif // LLD_READER_WRITER_ARM_ARM_ELF_READER_H

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

+//===--------- lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h -------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H
+#define LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H
+
+#include "ExecutableWriter.h"
+#include "ARMLinkingContext.h"
+
+namespace lld {
+namespace elf {
+
+template <class ELFT>
+class ARMExecutableWriter : public ExecutableWriter<ELFT> {
+public:
+  ARMExecutableWriter(ARMLinkingContext &context,
+                      ARMTargetLayout<ELFT> &layout);
+
+protected:
+  // Add any runtime files and their atoms to the output
+  bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+
+  void finalizeDefaultAtomValues() override {
+    // Finalize the atom values that are part of the parent.
+    ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
+  }
+
+  void addDefaultAtoms() override {
+    ExecutableWriter<ELFT>::addDefaultAtoms();
+  }
+
+private:
+  ARMLinkingContext &_context;
+  ARMTargetLayout<ELFT> &_armLayout;
+};
+
+template <class ELFT>
+ARMExecutableWriter<ELFT>::ARMExecutableWriter(ARMLinkingContext &context,
+                                               ARMTargetLayout<ELFT> &layout)
+    : ExecutableWriter<ELFT>(context, layout), _context(context),
+      _armLayout(layout) {}
+
+template <class ELFT>
+bool ARMExecutableWriter<ELFT>::createImplicitFiles(
+    std::vector<std::unique_ptr<File>> &result) {
+  ExecutableWriter<ELFT>::createImplicitFiles(result);
+  return true;
+}
+
+} // namespace elf
+} // namespace lld
+
+#endif // LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.h

+//===--------- lib/ReaderWriter/ELF/ARM/ARMLinkingContext.h ---------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_READER_WRITER_ELF_ARM_ARM_LINKING_CONTEXT_H
+#define LLD_READER_WRITER_ELF_ARM_ARM_LINKING_CONTEXT_H
+
+#include "ARMTargetHandler.h"
+
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/ELF.h"
+
+namespace lld {
+namespace elf {
+
+class ARMLinkingContext final : public ELFLinkingContext {
+public:
+  ARMLinkingContext(llvm::Triple triple)
+      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
+                                      new ARMTargetHandler(*this))) {}
+
+  void addPasses(PassManager &) override;
+
+  uint64_t getBaseAddress() const override {
+    if (_baseAddress == 0)
+      return 0x400000;
+    return _baseAddress;
+  }
+};
+} // end namespace elf
+} // end namespace lld
+
+#endif

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.cpp

+//===--------- lib/ReaderWriter/ELF/ARM/ARMLinkingContext.cpp -------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ARMLinkingContext.h"
+#include "ARMRelocationPass.h"
+
+using namespace lld;
+using namespace lld::elf;
+
+void elf::ARMLinkingContext::addPasses(PassManager &pm) {
+  auto pass = createARMRelocationPass(*this);
+  if (pass)
+    pm.add(std::move(pass));
+  ELFLinkingContext::addPasses(pm);
+}

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.h

+//===--------- lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.h ------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_READER_WRITER_ELF_ARM_ARM_RELOCATION_HANDLER_H
+#define LLD_READER_WRITER_ELF_ARM_ARM_RELOCATION_HANDLER_H
+
+#include "ARMTargetHandler.h"
+
+namespace lld {
+namespace elf {
+typedef llvm::object::ELFType<llvm::support::little, 2, false> ARMELFType;
+
+template <class ELFT> class ARMTargetLayout;
+
+class ARMTargetRelocationHandler final
+    : public TargetRelocationHandler {
+public:
+  std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
+                                  const lld::AtomLayout &,
+                                  const Reference &) const override;
+};
+
+} // end namespace elf
+} // end namespace lld
+
+#endif // LLD_READER_WRITER_ELF_ARM_ARM_RELOCATION_HANDLER_H

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

+//===--------- lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp ----------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ARMTargetHandler.h"
+#include "ARMLinkingContext.h"
+
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/MathExtras.h"
+
+using namespace lld;
+using namespace elf;
+
+static Reference::Addend readAddend_ARM_CALL(const uint8_t *location) {
+  const auto value = int32_t(
+      *reinterpret_cast<const llvm::support::little32_t *>(location));
+
+  const bool isBLX = (value & 0xF0000000) == 0xF0000000;
+  const int32_t bitH = isBLX ? ((value & 0x1000000) >> 24) : 0;
+
+  const int32_t result = ((value & 0xFFFFFF) << 2) | (bitH << 1);
+  return llvm::SignExtend64<26>(result);
+}
+
+static Reference::Addend readAddend(const uint8_t *location,
+                                    Reference::KindValue kindValue) {
+  switch (kindValue) {
+  case R_ARM_ABS32:
+    return int32_t(
+        *reinterpret_cast<const llvm::support::little32_t *>(location));
+  case R_ARM_CALL:
+    return readAddend_ARM_CALL(location);
+  default:
+    return 0;
+  }
+}
+
+static inline void applyArmReloc(uint8_t *location, uint32_t result,
+                                 uint32_t mask = 0xFFFFFFFF) {
+  assert(!(result & ~mask));
+  *reinterpret_cast<llvm::support::ulittle32_t *>(location) =
+      (uint32_t(*reinterpret_cast<llvm::support::ulittle32_t *>(location)) &
+       ~mask) | (result & mask);
+}
+
+/// \brief R_ARM_ABS32 - (S + A) | T => S + A
+static void relocR_ARM_ABS32(uint8_t *location, uint64_t P, uint64_t S,
+                             int64_t A) {
+  uint32_t result = (uint32_t)(S + A);
+  DEBUG_WITH_TYPE(
+      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+      llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
+      llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
+      llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
+      llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
+  applyArmReloc(location, result);
+}
+
+/// \brief R_ARM_CALL - ((S + A) | T) - P => S + A - P
+static void relocR_ARM_CALL(uint8_t *location, uint64_t P, uint64_t S,
+                            int64_t A) {
+  uint32_t result = (uint32_t)((S + A) - P);
+  const uint32_t imm24 = (result & 0x03FFFFFC) >> 2;
+
+  DEBUG_WITH_TYPE(
+      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+      llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
+      llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
+      llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
+      llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
+  applyArmReloc(location, imm24, 0xFFFFFF);
+}
+
+std::error_code ARMTargetRelocationHandler::applyRelocation(
+    ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::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();
+
+  if (ref.kindNamespace() != Reference::KindNamespace::ELF)
+    return std::error_code();
+  assert(ref.kindArch() == Reference::KindArch::ARM);
+
+  // Calculate proper initial addend for the relocation
+  const Reference::Addend addend =
+      readAddend(location, ref.kindValue());
+
+  switch (ref.kindValue()) {
+  case R_ARM_NONE:
+    break;
+  case R_ARM_ABS32:
+    relocR_ARM_ABS32(location, relocVAddress, targetVAddress, addend);
+    break;
+  case R_ARM_CALL:
+    relocR_ARM_CALL(location, relocVAddress, targetVAddress, addend);
+    break;
+  default:
+    make_unhandled_reloc_error();
+  }
+
+  return std::error_code();
+}

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.h

+//===--------- lib/ReaderWriter/ELF/ARM/ARMRelocationPass.h ---------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Declares the relocation processing pass for ARM. This includes
+///   GOT and PLT entries, TLS, COPY, and ifunc.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_READER_WRITER_ELF_ARM_ARM_RELOCATION_PASS_H
+#define LLD_READER_WRITER_ELF_ARM_ARM_RELOCATION_PASS_H
+
+#include <memory>
+
+namespace lld {
+class Pass;
+namespace elf {
+class ARMLinkingContext;
+
+/// \brief Create ARM relocation pass for the given linking context.
+std::unique_ptr<Pass> createARMRelocationPass(const ARMLinkingContext &);
+}
+}
+
+#endif

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

+//===--------- lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp -------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Defines the relocation processing pass for ARM. This includes
+///   GOT and PLT entries, TLS, COPY, and ifunc.
+///
+/// This also includes additional behavior that gnu-ld and gold implement but
+/// which is not specified anywhere.
+///
+//===----------------------------------------------------------------------===//
+
+#include "ARMRelocationPass.h"
+
+#include "lld/Core/Simple.h"
+
+#include "llvm/ADT/DenseMap.h"
+
+#include "Atoms.h"
+#include "ARMLinkingContext.h"
+#include "llvm/Support/Debug.h"
+
+using namespace lld;
+using namespace lld::elf;
+using namespace llvm::ELF;
+
+namespace {
+class ELFPassFile : public SimpleFile {
+public:
+  ELFPassFile(const ELFLinkingContext &eti) : SimpleFile("ELFPassFile") {
+    setOrdinal(eti.getNextOrdinalAndIncrement());
+  }
+
+  llvm::BumpPtrAllocator _alloc;
+};
+
+/// \brief CRTP base for handling relocations.
+template <class Derived> class ARMRelocationPass : public Pass {
+  /// \brief Handle a specific reference.
+  void handleReference(const DefinedAtom &atom, const Reference &ref) {
+    DEBUG_WITH_TYPE(
+        "ARM", llvm::dbgs() << "\t" << LLVM_FUNCTION_NAME << "()"
+            << ":   Name of Defined Atom: " << atom.name().str();
+        llvm::dbgs() << "   kindValue: " << ref.kindValue() << "\n");
+    if (ref.kindNamespace() != Reference::KindNamespace::ELF)
+      return;
+    assert(ref.kindArch() == Reference::KindArch::ARM);
+    switch (ref.kindValue()) {
+    }
+  }
+
+protected:
+public:
+  ARMRelocationPass(const ELFLinkingContext &ctx)
+      : _file(ctx), _ctx(ctx) {}
+
+  /// \brief Do the pass.
+  ///
+  /// The goal here is to first process each reference individually. Each call
+  /// to handleReference may modify the reference itself and/or create new
+  /// atoms which must be stored in one of the maps below.
+  ///
+  /// After all references are handled, the atoms created during that are all
+  /// added to mf.
+  void perform(std::unique_ptr<MutableFile> &mf) override {
+    ScopedTask task(getDefaultDomain(), "ARM GOT/PLT Pass");
+    DEBUG_WITH_TYPE(
+        "ARM", llvm::dbgs() << "Undefined Atoms" << "\n";
+        for (const auto &atom
+             : mf->undefined()) {
+          llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
+        }
+
+        llvm::dbgs() << "Shared Library Atoms" << "\n";
+        for (const auto &atom
+             : mf->sharedLibrary()) {
+          llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
+        }
+
+        llvm::dbgs() << "Absolute Atoms" << "\n";
+        for (const auto &atom
+             : mf->absolute()) {
+          llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
+        }
+
+        llvm::dbgs() << "Defined Atoms" << "\n";
+        for (const auto &atom
+             : mf->defined()) {
+          llvm::dbgs() << " Name of Atom: " << atom->name().str() << "\n";
+        });
+
+    // Process all references.
+    for (const auto &atom : mf->defined()) {
+      for (const auto &ref : *atom) {
+        handleReference(*atom, *ref);
+      }
+    }
+  }
+
+protected:
+  /// \brief Owner of all the Atoms created by this pass.
+  ELFPassFile _file;
+  const ELFLinkingContext &_ctx;
+};
+
+/// This implements the static relocation model. Meaning GOT and PLT entries are
+/// not created for references that can be directly resolved. These are
+/// converted to a direct relocation. For entries that do require a GOT or PLT
+/// entry, that entry is statically bound.
+///
+/// TLS always assumes module 1 and attempts to remove indirection.
+class ARMStaticRelocationPass final
+    : public ARMRelocationPass<ARMStaticRelocationPass> {
+public:
+  ARMStaticRelocationPass(const elf::ARMLinkingContext &ctx)
+      : ARMRelocationPass(ctx) {}
+};
+
+} // end anon namespace
+
+std::unique_ptr<Pass>
+lld::elf::createARMRelocationPass(const ARMLinkingContext &ctx) {
+  switch (ctx.getOutputELFType()) {
+  case llvm::ELF::ET_EXEC:
+    if (ctx.isDynamic())
+      llvm_unreachable("Unhandled output file type");
+    else
+      return std::unique_ptr<Pass>(new ARMStaticRelocationPass(ctx));
+  default:
+    llvm_unreachable("Unhandled output file type");
+  }
+}

lib/ReaderWriter/ELF/ARM/ARMTarget.h

+//===--------- lib/ReaderWriter/ELF/ARM/ARMTarget.h -----------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ARMLinkingContext.h"

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

+//===--------- lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h ----------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_READER_WRITER_ELF_ARM_ARM_TARGET_HANDLER_H
+#define LLD_READER_WRITER_ELF_ARM_ARM_TARGET_HANDLER_H
+
+#include "ARMELFFile.h"
+#include "ARMELFReader.h"
+#include "ARMRelocationHandler.h"
+#include "DefaultTargetHandler.h"
+#include "TargetLayout.h"
+
+#include "lld/Core/Simple.h"
+#include "llvm/ADT/Optional.h"
+#include <map>
+
+namespace lld {
+namespace elf {
+typedef llvm::object::ELFType<llvm::support::little, 2, false> ARMELFType;
+class ARMLinkingContext;
+
+template <class ELFT> class ARMTargetLayout : public TargetLayout<ELFT> {
+public:
+  ARMTargetLayout(ARMLinkingContext &context)
+      : TargetLayout<ELFT>(context) {}
+};
+
+class ARMTargetHandler final : public DefaultTargetHandler<ARMELFType> {
+public:
+  ARMTargetHandler(ARMLinkingContext &context);
+
+  ARMTargetLayout<ARMELFType> &getTargetLayout() override {
+    return *(_armTargetLayout.get());
+  }
+
+  void registerRelocationNames(Registry &registry) override;
+
+  const ARMTargetRelocationHandler &getRelocationHandler() const override {
+    return *(_armRelocationHandler.get());
+  }
+
+  std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
+    return std::unique_ptr<Reader>(new ARMELFObjectReader(atomizeStrings));
+  }
+
+  std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
+    return std::unique_ptr<Reader>(new ARMELFDSOReader(useShlibUndefines));
+  }
+
+  std::unique_ptr<Writer> getWriter() override;
+
+private:
+  static const Registry::KindStrings kindStrings[];
+  ARMLinkingContext &_context;
+  std::unique_ptr<ARMTargetLayout<ARMELFType>> _armTargetLayout;
+  std::unique_ptr<ARMTargetRelocationHandler> _armRelocationHandler;
+};
+
+} // end namespace elf
+} // end namespace lld
+
+#endif // LLD_READER_WRITER_ELF_ARM_ARM_TARGET_HANDLER_H

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp

+//===--------- lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp --------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Atoms.h"
+#include "ARMExecutableWriter.h"
+#include "ARMTargetHandler.h"
+#include "ARMLinkingContext.h"
+
+using namespace lld;
+using namespace elf;
+
+ARMTargetHandler::ARMTargetHandler(ARMLinkingContext &context)
+    : _context(context), _armTargetLayout(
+          new ARMTargetLayout<ARMELFType>(context)),
+      _armRelocationHandler(new ARMTargetRelocationHandler()) {}
+
+void ARMTargetHandler::registerRelocationNames(Registry &registry) {
+  registry.addKindTable(Reference::KindNamespace::ELF, Reference::KindArch::ARM,
+                        kindStrings);
+}
+
+std::unique_ptr<Writer> ARMTargetHandler::getWriter() {
+  switch (this->_context.getOutputELFType()) {
+  case llvm::ELF::ET_EXEC:
+    return std::unique_ptr<Writer>(
+        new ARMExecutableWriter<ARMELFType>(_context, *_armTargetLayout.get()));
+  default:
+    llvm_unreachable("unsupported output type");
+  }
+}
+
+#define ELF_RELOC(name, value) LLD_KIND_STRING_ENTRY(name),
+
+const Registry::KindStrings ARMTargetHandler::kindStrings[] = {
+#include "llvm/Support/ELFRelocs/ARM.def"
+    LLD_KIND_STRING_END
+};

lib/ReaderWriter/ELF/ARM/CMakeLists.txt

+add_lld_library(lldARMELFTarget
+  ARMLinkingContext.cpp
+  ARMTargetHandler.cpp
+  ARMRelocationHandler.cpp
+  ARMRelocationPass.cpp
+  )
+
+target_link_libraries(lldARMELFTarget ${cmake_2_8_12_INTERFACE}
+  lldCore
+  )

lib/ReaderWriter/ELF/ARM/Makefile

+##===------ lld/lib/ReaderWriter/ELF/ARM/Makefile ----------*- Makefile -*-===##
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+
+LLD_LEVEL := ../../../..
+LIBRARYNAME := lldARMELFTarget
+USEDLIBS = lldCore.a
+CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLD_LEVEL)/lib/ReaderWriter/ELF/ARM -I$(PROJ_SRC_DIR)/$(LLD_LEVEL)/lib/ReaderWriter/ELF
+
+include $(LLD_LEVEL)/Makefile

lib/ReaderWriter/ELF/ARM/TODO.rst

+ELF ARM
+~~~~~~~~~~~
+
+Unimplemented Features
+######################
+
+* Static executable linking - in progress
+* Dynamic executable linking
+* DSO linking
+* PLT entries' generation for images larger than 2^28 bytes (see Sec. A.3 of the ELF reference)
+* ARM and Thumb interworking (see http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0203j/Bcghfebi.html)
+* .ARM.exidx section handling
+* -init/-fini options
+* Lots of relocations
+
+Unimplemented Relocations
+#########################
+
+All of these relocations are defined in:
+http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044e/IHI0044E_aaelf.pdf

lib/ReaderWriter/ELF/Atoms.h

void addReferenceELF_Mips(uint16_t relocType, uint64_t off, const Atom *t,
                             Reference::Addend a) {
     this->addReferenceELF(Reference::KindArch::Mips, relocType, off, t, a);
   }
 
   void addReferenceELF_AArch64(uint16_t relocType, uint64_t off, const Atom *t,
                                Reference::Addend a) {
     this->addReferenceELF(Reference::KindArch::AArch64, relocType, off, t, a);
   }
+
+  void addReferenceELF_ARM(uint16_t relocType, uint64_t off, const Atom *t,
+                               Reference::Addend a) {
+    this->addReferenceELF(Reference::KindArch::ARM, relocType, off, t, a);
+  }
 };
 
 /// \brief Atom which represents an object for which a COPY relocation will be
 ///   generated.
 class ObjectAtom : public SimpleELFDefinedAtom {
 public:
   ObjectAtom(const File &f) : SimpleELFDefinedAtom(f) {}
 

lib/ReaderWriter/ELF/CMakeLists.txt

 add_lld_library(lldELF
   ArrayOrderPass.cpp
   ELFLinkingContext.cpp
   Reader.cpp
   Writer.cpp
   )
 
 target_link_libraries(lldELF ${cmake_2_8_12_INTERFACE}
   lldHexagonELFTarget
   lldMipsELFTarget
   lldPPCELFTarget
   lldPasses
   lldReaderWriter
   lldX86ELFTarget
   lldX86_64ELFTarget
   lldAArch64ELFTarget
+  lldARMELFTarget
   )
 
 include_directories(.)
 
 add_subdirectory(X86)
 add_subdirectory(X86_64)
 add_subdirectory(PPC)
 add_subdirectory(Mips)
 add_subdirectory(Hexagon)
 add_subdirectory(AArch64)
+add_subdirectory(ARM)

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

uint16_t ELFLinkingContext::getOutputMachine() const {
   case llvm::Triple::hexagon:
     return llvm::ELF::EM_HEXAGON;
   case llvm::Triple::mipsel:
     return llvm::ELF::EM_MIPS;
   case llvm::Triple::ppc:
     return llvm::ELF::EM_PPC;
   case llvm::Triple::aarch64:
     return llvm::ELF::EM_AARCH64;
+  case llvm::Triple::arm:
+    return llvm::ELF::EM_ARM;
   default:
     llvm_unreachable("Unhandled arch");
   }
 }
 
 StringRef ELFLinkingContext::entrySymbolName() const {
   if (_outputELFType == elf::ET_EXEC && _entrySymbolName.empty())
     return "_start";
case llvm::Triple::mipsel:
     return std::unique_ptr<ELFLinkingContext>(
         new lld::elf::MipsLinkingContext(triple));
   case llvm::Triple::ppc:
     return std::unique_ptr<ELFLinkingContext>(
         new lld::elf::PPCLinkingContext(triple));
   case llvm::Triple::aarch64:
     return std::unique_ptr<ELFLinkingContext>(
         new lld::elf::AArch64LinkingContext(triple));
+  case llvm::Triple::arm:
+    return std::unique_ptr<ELFLinkingContext>(
+        new lld::elf::ARMLinkingContext(triple));
   default:
     return nullptr;
   }
 }
 
 static void buildSearchPath(SmallString<128> &path, StringRef dir,
                             StringRef sysRoot) {
   if (!dir.startswith("=/"))

lib/ReaderWriter/ELF/Targets.h

 //===- lib/ReaderWriter/ELF/Targets.h -------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_READER_WRITER_ELF_TARGETS_H
 #define LLD_READER_WRITER_ELF_TARGETS_H
 
 #include "AArch64/AArch64Target.h"
+#include "ARM/ARMTarget.h"
 #include "Hexagon/HexagonTarget.h"
 #include "Mips/MipsTarget.h"
 #include "PPC/PPCTarget.h"
 #include "X86/X86Target.h"
 #include "X86_64/X86_64Target.h"
 
 #endif

test/elf/ARM/defsym.test

+# Check that defined symbols are present in the generated executable
+
+# RUN: yaml2obj -format=elf %s > %t-o.o
+# RUN: lld -flavor gnu -target arm-linux-gnu --defsym=main=fn -e=fn \
+# RUN: -static --noinhibit-exec %t-o.o -o %t
+# RUN: llvm-readobj -symbols %t | FileCheck %s
+
+# CHECK: Symbol {
+# CHECK:   Name: main (1)
+# CHECK:   Value: 0x400075
+# CHECK:   Size: 0
+# CHECK:   Binding: Global (0x1)
+# CHECK:   Type: Function (0x2)
+# CHECK:   Other: 0
+# CHECK:   Section: .text (0x1)
+# CHECK: }
+# CHECK: Symbol {
+# CHECK:   Name: fn (6)
+# CHECK:   Value: 0x400075
+# CHECK:   Size: 15
+# CHECK:   Binding: Global (0x1)
+# CHECK:   Type: Function (0x2)
+# CHECK:   Other: 0
+# CHECK:   Section: .text (0x1)
+# CHECK: }
+
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         80B400AF00231846BD465DF8047B7047
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .note.GNU-stack
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Local:
+    - Name:            .text
+      Type:            STT_SECTION
+      Section:         .text
+    - Name:            .data
+      Type:            STT_SECTION
+      Section:         .data
+    - Name:            .bss
+      Type:            STT_SECTION
+      Section:         .bss
+    - Name:            .note.GNU-stack
+      Type:            STT_SECTION
+      Section:         .note.GNU-stack
+  Global:
+    - Name:            fn
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+      Size:            0x0000000000000010
+...

test/elf/ARM/rel-abs32.test

+# Check handling of R_ARM_ABS32 relocation.
+# RUN: yaml2obj -format=elf %s > %t-o.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: --noinhibit-exec %t-o.o -o %t
+# RUN: llvm-objdump -s -t %t | FileCheck %s
+
+# CHECK: Contents of section .data:
+# CHECK-NEXT: 401000 84004000
+#      data = 0x400084 ^^
+#               data     main addr  content
+#             0x400084 = 0x400074 + 0x10
+# CHECK: SYMBOL TABLE:
+# CHECK: 00400074 g     F .text  0000001c main
+# CHECK: 00401000 g       .data  00000004 data
+
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         04B02DE500B08DE20030A0E30300A0E100D04BE204B09DE41EFF2FE1
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         '10000000'
+  - Name:            .rel.data
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .data
+    Relocations:
+      - Offset:          0x0000000000000000
+        Symbol:          main
+        Type:            R_ARM_ABS32
+        Addend:          0
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Global:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Size:            0x000000000000001C
+    - Name:            data
+      Type:            STT_OBJECT
+      Section:         .data
+      Size:            0x0000000000000004
+...

test/elf/ARM/rel-arm-call.test

+# Check handling of R_ARM_CALL relocation.
+# RUN: yaml2obj -format=elf %s > %t-o.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: --noinhibit-exec %t-o.o -o %t
+# RUN: llvm-objdump -s -t %t | FileCheck %s
+
+# CHECK: Contents of section .text:
+# CHECK: 400084 1eff2fe1 00482de9 04b08de2 f7ffffeb
+#                          offset = -0x24  ^^
+#               call site  offset  PC(arm) _Z1fv addr
+#               0x400090 + (-0x24) + 0x8 = 0x400074
+# CHECK: SYMBOL TABLE:
+# CHECK: 00400074 g     F .text  00000014 _Z1fv
+# CHECK: 00400088 g     F .text  00000018 main
+
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         04B02DE500B08DE200D04BE204B09DE41EFF2FE100482DE904B08DE2FEFFFFEB0030A0E30300A0E10088BDE8
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text
+    Relocations:
+      - Offset:          0x000000000000001C
+        Symbol:          _Z1fv
+        Type:            R_ARM_CALL
+        Addend:          0
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Global:
+    - Name:            _Z1fv
+      Type:            STT_FUNC
+      Section:         .text
+      Size:            0x0000000000000014
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000014
+      Size:            0x0000000000000018
+...