Linking of shared libraries for MIPS little-endian 32-bit target

[atanasyan]

Summary

The patch implements linking of shared libraries for MIPS little-endian 32-bit target. Now supported a limited set of relocations and linking is possible in trivial cases only.

The following are the most significant peculiarities of MIPS target:

• MIPS ABI requires some special tags in the dynamic table.
• GOT consists of two parts local and global. The local part contains entries refer locally visible symbols. The global part contains entries refer global symbols.
• Entries in the .dynsym section which have corresponded entries in the GOT should be:
  1. Emitted at the end of .dynsym section
  2. Sorted accordingly to theirs GOT counterparts
• There are “paired” relocations. One or more R_MIPS_HI16 and R_MIPS_GOT16 relocations should be followed by R_MIPS_LO16 relocation. To calculate result of R_MIPS_HI16 and R_MIPS_GOT16 relocations we need to combine addends from these relocations and paired R_MIPS_LO16 relocation.

Could you please review the patch? Any suggestions or objections are very appreciated.

[Bigcheese]

Other than that it looks good here.

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

40

This isn't a great place for this as it preserves atom pointers from a specific pass, which are not guaranteed to be stable. It seems that it's only used for the local and global offsets of the got. I think a better option here would be to calculate the offsets in the layout by iterating over the final .got MergedSection.

lib/ReaderWriter/ELF/TargetHandler.h

125

No indentation.

130

No indentation.

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

18 ↗

(On Diff #5478)

This is an unrelated (and incorrect) change.

[shankarke]

lib/ReaderWriter/ELF/DefaultTargetHandler.h

62–78

remove all parameters to this function. alloc should be owned by the TargetHandler for Mips. name/order could be completely decided by Mips too.

lib/ReaderWriter/ELF/Mips/MipsELFTypes.h

1–20 ↗

(On Diff #5478)

why does this need a separate header file ? This would go in MipsLinkingContext

lib/ReaderWriter/ELF/Mips/MipsGOT.cpp

90 ↗

(On Diff #5478)

Why 2 + ?

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

61

not the right place for holding to the got.

72–74

move compareGOT outside the LinkingContext. The LinkingContext should just have just flags that determine what and how to link.

121–122

add else case and llvm_unreachable.

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

24–32

I dont like the interface that LinkingContext is having a lot of helper function. The LinkingContext contains only what and how the linking is done(mainly flags) and very few generic helper functions. This interface sounds like its not dealing with LinkingContext in that way.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

28–30

not sure what this comment is addressing.

32–33

the comments are describing parameters that are different in names.

40–41

the comments are describing parameters that are different in names.

45

nit pick. empty lines

73–75

the comments are describing parameters that are different in names. AHL is not being calculated here too.

84–85

the comments are describing parameters that are different in names.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.h

43–47

merge this private declaration with above. seen similiar declarations in other places too (protected ...)

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp

28

Didnt find a call to this function.

29–30

I thought you want to sort all the atoms in the symbolTable, why stable_sort ?

172

assert if these atoms are not found.

174

Why are you adding 0x7FF0, this might be difficult to support when we have linker script support.

lib/ReaderWriter/ELF/SectionChunks.h

608

I dont know what does the llvm guideline say with classes having two sets of protected fields, to reduce confusion, you might want to move to the same place where other protected members are.

613

unrelated change ?

990

same as previous.

1018–1020

an operator is better.

lib/ReaderWriter/ELF/TargetHandler.h

130

can we remove alloc and order here.

[ruiu]

lib/ReaderWriter/ELF/Mips/MipsELFTypes.h

17 ↗

(On Diff #5478)

Is this the only architecture you're going to support? Should we name Mips32ELFType?

lib/ReaderWriter/ELF/Mips/MipsGOT.cpp

69 ↗

(On Diff #5478)

s/auto/bool/

79 ↗

(On Diff #5478)

I'd write like this instead of #ifndef

DEBUG_WITH_TYPE("MipsGOT", {
    ga->name = ...
    ...
    llvm::dbgs() << ...
 });

Note that it's probably better to use MipsGOT or something instead of GOT.

100 ↗

(On Diff #5478)

No need to use #ifndef. DEBUG_WITH_TYPE will be expanded to do{}while(0) if NDEBUG is not defined.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

26

Why macro? Can it be an inline function?

34

In LLD local variables usually start with a lowercase letter.

189

nit: s.str() would flush the stream and then return the result string, so you can remove the line above.

lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h

28

2^16 is too large. Typo of 4?

lib/ReaderWriter/ELF/Mips/MipsTarget.h

11

Do you really need this file?

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

28

"ti" standed for "target info". Because LinkingContext used to be named TargetInfo, some local variables still contain "ti". It no longer makes sense. I'd think "ctx" is preferred.

[atanasyan]

Thanks for review. I put my answers and questions inline.

lib/ReaderWriter/ELF/DefaultTargetHandler.h

62–78

Just want to be sure that I understand you properly. Do you suggest to delete default implementations of createDynamicTable() and createDynamicSymbolTable() from the DefaultTargetHandler and define these functions as well as allocator in each target handlers for each supported targets (x86, x86_64, hexagon, mips etc)?

lib/ReaderWriter/ELF/Mips/MipsELFTypes.h

1–20 ↗

(On Diff #5478)

OK

17 ↗

(On Diff #5478)

Agree. I will rename it to the Mips32ElELFType.

lib/ReaderWriter/ELF/Mips/MipsGOT.cpp

69 ↗

(On Diff #5478)

OK

79 ↗

(On Diff #5478)

OK

90 ↗

(On Diff #5478)

The GOT contains two reserved entries: lazy resolver and module pointer. But I agree that hardcoded constant is not a good solution. I will handle all GOT entries in a uniform way and remove this constant.

100 ↗

(On Diff #5478)

OK

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

61

OK. I will fix that.

72–74

OK. I will fix that.

121–122

OK

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

24–32

OK. I will fix that.

40

OK. I will fix that.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

26

I will replace this macros by inline function.

28–30

OK. I will reformat comments for relocation handling function.

32–33

The comment mentions A and S, parameter's names are A and S. Where is the difference?

34

It looks like this rule is violated in the X86_64RelocationHandler.cpp and HexagonRelocationHandler.cpp. I know the reason - P, S, A names are used in the corresponding ABI specification. It simplify reading and understanding the code if we keep these names unchanged.

40–41

OK. I will fix that,

45

OK

73–75

OK. I will fix that.

84–85

OK. I will fix that.

189

OK. I will fix that.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.h

43–47

OK

lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h

28

OK. I will fix that.

lib/ReaderWriter/ELF/Mips/MipsTarget.h

11

The lib/ReaderWriter/ELF/Targets.h includes xxxTarget.h files for each supported target. All these files look similar and include only xxxLinkingContext.h. I keep to the established order and do the same thing for the MIPS target.

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp

28

OutputELFWriter<ELFT>::buildDynamicSymbolTable()
and
SymbolTable<ELFT>::finalize()

29–30

I want to sort all atoms in the symbolTable which have corresponding entries in the global part of GOT. These atoms are subset of the symbolTable. So I do not want to change an order of other atoms.

172

OK

174

OK. I will move this constant to the separate function.

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

28

OK. I will fix that.

lib/ReaderWriter/ELF/SectionChunks.h

608

OK. I will fix that.

613

Yes. I will fix that.

990

OK. I will fix that.

1018–1020

This time only MipsDynamicTable which is successor of DynamicTable needs access to the _entries. I will remove the DynamicTable::getEntry() method and move the DynamicTable::_entries field to the protected section.

lib/ReaderWriter/ELF/TargetHandler.h

125

OK. I will fix that.

130

OK. I will fix that.

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

18 ↗

(On Diff #5478)

OK. I will fix that.

[atanasyan]

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

18 ↗

(On Diff #5478)

I agree that this change is unrelated but I found rather strange things related to the X86TargetHandler class. This class is inherited from the DefaultTargetHandler class template which is instantiated using the X86ELFType type. The X86ELFType::MaxAlignment equals to 2. When we emit an ELF output file for X86 target we use a writer class inherited from the OutputELFWriter<ELFT> class where ELFT::MaxAlignment equals to 4. That is the strange thing number one. The strange thing number two is a constructor of the OutputELFWriter class. In this constructor (in case of X86 target) we make a dangerous cast. In fact we cast between different successor of the TargetHandlerBase class.

Is it a deliberate decision or mistake?

[Bigcheese]

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

18 ↗

(On Diff #5478)

Mistake. We should always use 2 byte alignment because of archives. Although the layout is exactly the same for both.

[atanasyan]

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

40

It looks like my answer "I will fix that" was too optimistic.

I need to know a GOT content to perform the following actions:

• Emit DT_MIPS_LOCAL_GOTNO (depends on number of local GOT entries) and DT_MIPS_GOTSYM (depends on number of global GOT entries) dynamic table tags.
• Sort dynamic symbol table's atoms which have corresponding entries in the global part of GOT. The dynamic symbol entries should go at the same order as their GOT complements.
• Initialize GOT entries related to the R_MIPS_GOT16 relocation. These GOT entries should be initialized by values calculated during the R_MIPS_GOT16 relocation processing. This action is not implemented in this patch.

Unfortunately I cannot figure out how to complete all these actions by iterating over the final .got MergedSection. Could you please provide more hints?

[shankarke]

lib/ReaderWriter/ELF/DefaultTargetHandler.h

62–78

createDynamicTable would just return DynamicTable<ELFT> section.

If the targets override that functionality they could return a DynamicTable<ELFT> section. All the required parameters needed for creating the Target specific DynamicTable section is present in the TargetHandler.

[shankarke]

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

40

You could override createSection/createDynamicTable in the TargetLayout/TargetHandler respecitively. With this the Mips Target is in complete control of how the section gets written. Will this work ?

[Bigcheese]

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

40

You should sort the GOT atoms after they are all created in a pass. Then iterate over them in the writer to get the counts.

Then use a custom dynamic symbol table section impl that sorts the same way.

[atanasyan]

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

40

For dynamic symbol table sorting I need to get a GOT entry position for the given symbol. What is the best way to maintain a mapping between GOT atom and corresponding symbol? Is it OK to add a reference to the symbol for pointing to the GOT atom?

[atanasyan]

Could you please review the new patch? I hope all issues found on the previous review iteration have been resolved.

[shankarke]

Apart from the comments above, LGTM.

lib/ReaderWriter/ELF/DefaultLayout.h

201–207

You may want to remove this duplicate function.

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp

106

You could use the same function findOutputSection by removing const.

[ruiu]

LGTM with a few comments. Please run clang-format on your patch before submitting.

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

59

eti -> ctx?

124

You might want to add llvm_unreachable for other cases.

137

Add parentheses around the right hand side of the assignment for readabililty.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

24

Is "|" correct? I don't know about MIPS relocation types but in COFF it's "+".

[atanasyan]

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

124

Not all MIPS relocation require GOT entries so it is ok to do nothing in this method sometimes. That is why I prefer to keep this code unchanged.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

24

Yes, "|" is correct. By the way the same code are in the Hexagon and X86_64 ELF targets.

[atanasyan]

Abandon this revision to cleanup the "Waiting on Others" list. The significantly rewritten patch has been committed at rL197342.

lib/ReaderWriter/ELF/CMakeLists.txt

 add_lld_library(lldELF
   ArrayOrderPass.cpp
   ELFLinkingContext.cpp
   Reader.cpp
   Writer.cpp
   )
 
 target_link_libraries(lldELF
   lldHexagonELFTarget
+  lldMipsELFTarget
   lldPPCELFTarget
   lldPasses
   lldReaderWriter
   lldX86ELFTarget
   lldX86_64ELFTarget
   )
 
 include_directories(.)

lib/ReaderWriter/ELF/DefaultLayout.h

public:
   /// \brief Find an output Section given a section name.
   MergedSections<ELFT> *findOutputSection(StringRef name) {
     auto iter = _mergedSectionMap.find(name);
     if (iter == _mergedSectionMap.end())
       return nullptr;
     return iter->second;
   }
 
+  /// \brief Find an output Section given a section name.
+  const MergedSections<ELFT> *findOutputSection(StringRef name) const {
+    auto iter = _mergedSectionMap.find(name);
+    if (iter == _mergedSectionMap.end())
+      return nullptr;
+    return iter->second;
+  }
+
   /// \brief find a absolute atom given a name
   AbsoluteAtomIterT findAbsoluteAtom(StringRef name) {
     return std::find_if(_absoluteAtoms.begin(), _absoluteAtoms.end(),
                         FindByName(name));
   }
 
   // Merge sections with the same name into a MergedSections
   void mergeSimilarSections();

lib/ReaderWriter/ELF/DefaultTargetHandler.h

public:
   }
 
   /// \brief Finalize the symbol values
   void finalizeSymbolValues() {}
 
   /// \brief allocate Commons, some architectures may move small common
   /// symbols over to small data, this would also be used
   void allocateCommons() {}
+
+  /// \brief create dynamic table
+  LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>) createDynamicTable() {
+    return LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>)(
+        new (_alloc) DynamicTable<ELFT>(
+            this->_context, ".dynamic", DefaultLayout<ELFT>::ORDER_DYNAMIC));
+  }
+
+  /// \brief create dynamic symbol table
+  LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>) createDynamicSymbolTable() {
+    return LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)(
+        new (_alloc) DynamicSymbolTable<ELFT>(
+            this->_context, ".dynsym",
+            DefaultLayout<ELFT>::ORDER_DYNAMIC_SYMBOLS));
+  }
+
+private:
+  llvm::BumpPtrAllocator _alloc;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

 uint16_t ELFLinkingContext::getOutputMachine() const {
   switch (getTriple().getArch()) {
   case llvm::Triple::x86:
     return llvm::ELF::EM_386;
   case llvm::Triple::x86_64:
     return llvm::ELF::EM_X86_64;
   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;
   default:
     llvm_unreachable("Unhandled arch");
   }
 }
 
 StringRef ELFLinkingContext::entrySymbolName() const {
case llvm::Triple::x86:
     return std::unique_ptr<ELFLinkingContext>(
         new lld::elf::X86LinkingContext(triple));
   case llvm::Triple::x86_64:
     return std::unique_ptr<ELFLinkingContext>(
         new lld::elf::X86_64LinkingContext(triple));
   case llvm::Triple::hexagon:
     return std::unique_ptr<ELFLinkingContext>(
         new lld::elf::HexagonLinkingContext(triple));
+  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));
   default:
     return nullptr;
   }
 }
 

lib/ReaderWriter/ELF/Mips/CMakeLists.txt

+add_lld_library(lldMipsELFTarget
+  MipsLinkingContext.cpp
+  MipsRelocationHandler.cpp
+  MipsTargetHandler.cpp
+  )
+
+target_link_libraries(lldMipsELFTarget
+  lldCore
+  )

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

+//===- lib/ReaderWriter/ELF/Mips/MipsLinkingContext.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_MIPS_LINKING_CONTEXT_H
+#define LLD_READER_WRITER_ELF_MIPS_LINKING_CONTEXT_H
+
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+
+namespace lld {
+namespace elf {
+
+typedef llvm::object::ELFType<llvm::support::little, 2, false> Mips32ElELFType;
+
+template <class ELFType>
+class MipsTargetLayout;
+
+class MipsLinkingContext LLVM_FINAL : public ELFLinkingContext {
+public:
+  MipsLinkingContext(llvm::Triple triple);
+
+  MipsTargetLayout<Mips32ElELFType> &getTargetLayout();
+  const MipsTargetLayout<Mips32ElELFType> &getTargetLayout() const;
+
+  // ELFLinkingContext
+  virtual bool isLittleEndian() const;
+  virtual ErrorOr<Reference::Kind> relocKindFromString(StringRef str) const;
+  virtual ErrorOr<std::string> stringFromRelocKind(Reference::Kind kind) const;
+  virtual void addPasses(PassManager &pm);
+};
+
+} // elf
+} // lld
+
+#endif

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

+//===- lib/ReaderWriter/ELF/Mips/MipsLinkingContext.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 "MipsLinkingContext.h"
+#include "MipsTargetHandler.h"
+
+#include "llvm/ADT/StringSwitch.h"
+
+using namespace lld;
+using namespace lld::elf;
+
+namespace {
+
+const uint8_t mipsGot0AtomContent[] = {
+  0x00, 0x00, 0x00, 0x00 // Lazy resolver
+};
+
+const uint8_t mipsGotModulePointerAtomContent[] = {
+  0x00, 0x00, 0x00, 0x80 // Module pointer
+};
+
+/// \brief Abstract base class represent MIPS GOT entries.
+class MipsGOTAtom : public GOTAtom {
+public:
+  MipsGOTAtom(const File &f) : GOTAtom(f, ".got") {}
+
+  virtual Alignment alignment() const { return Alignment(2); }
+};
+
+/// \brief MIPS GOT entry initialized by zero.
+class MipsGOT0Atom : public MipsGOTAtom {
+public:
+  MipsGOT0Atom(const File &f) : MipsGOTAtom(f) {}
+
+  virtual ArrayRef<uint8_t> rawContent() const {
+    return llvm::makeArrayRef(mipsGot0AtomContent);
+  }
+};
+
+/// \brief MIPS GOT entry initialized by zero.
+class MipsGOTModulePointerAtom : public MipsGOTAtom {
+public:
+  MipsGOTModulePointerAtom(const File &f) : MipsGOTAtom(f) {}
+
+  virtual ArrayRef<uint8_t> rawContent() const {
+    return llvm::makeArrayRef(mipsGotModulePointerAtomContent);
+  }
+};
+
+class MipsGOTPassFile : public SimpleFile {
+public:
+  MipsGOTPassFile(const ELFLinkingContext &eti)
+      : SimpleFile(eti, "MipsGOTPassFile") {
+    setOrdinal(eti.getNextOrdinalAndIncrement());
+  }
+
+  llvm::BumpPtrAllocator _alloc;
+};
+
+class MipsGOTPass : public Pass {
+public:
+  MipsGOTPass(MipsLinkingContext &context)
+      : _file(context),
+        _got0(new (_file._alloc) MipsGOT0Atom(_file)),
+        _got1(new (_file._alloc) MipsGOTModulePointerAtom(_file)) {
+    _localGotVector.push_back(_got0);
+    _localGotVector.push_back(_got1);
+  }
+
+  virtual void perform(std::unique_ptr<MutableFile> &mf) {
+    // Process all references.
+    for (const auto &atom : mf->defined())
+      for (const auto &ref : *atom)
+        handleReference(*atom, *ref);
+
+    uint64_t ordinal = 0;
+
+    for (auto &got : _localGotVector) {
+      DEBUG_WITH_TYPE("MipsGOT", llvm::dbgs() << "[ GOT ] Adding L "
+                                              << got->name() << "\n");
+      got->setOrdinal(ordinal++);
+      mf->addAtom(*got);
+    }
+
+    for (auto &got : _globalGotVector) {
+      DEBUG_WITH_TYPE("MipsGOT", llvm::dbgs() << "[ GOT ] Adding G "
+                                              << got->name() << "\n");
+      got->setOrdinal(ordinal++);
+      mf->addAtom(*got);
+    }
+  }
+
+private:
+  /// \brief Owner of all the Atoms created by this pass.
+  MipsGOTPassFile _file;
+
+  /// \brief GOT header entries.
+  GOTAtom *_got0;
+  GOTAtom *_got1;
+
+  /// \brief Map Atoms to their GOT entries.
+  llvm::DenseMap<const Atom *, GOTAtom *> _gotMap;
+
+  /// \brief the list of local GOT atoms.
+  std::vector<GOTAtom *> _localGotVector;
+
+  /// \brief the list of global GOT atoms.
+  std::vector<GOTAtom *> _globalGotVector;
+
+  /// \brief Handle a specific reference.
+  void handleReference(const DefinedAtom &atom, const Reference &ref) {
+    switch (ref.kind()) {
+    case R_MIPS_GOT16:
+    case R_MIPS_CALL16:
+      handleGOT(ref);
+      break;
+    }
+  }
+
+  void handleGOT(const Reference &ref) {
+    const_cast<Reference &>(ref).setTarget(getEntry(ref.target()));
+  }
+
+  const GOTAtom *getEntry(const Atom *a) {
+    auto got = _gotMap.find(a);
+    if (got != _gotMap.end())
+      return got->second;
+
+    const DefinedAtom *da = dyn_cast<DefinedAtom>(a);
+    bool isLocal = da && da->scope() == Atom::scopeTranslationUnit;
+
+    auto ga = new (_file._alloc) MipsGOT0Atom(_file);
+    _gotMap[a] = ga;
+    if (isLocal)
+      _localGotVector.push_back(ga);
+    else {
+      if (da)
+        ga->addReference(R_MIPS_32, 0, a, 0);
+      else
+        ga->addReference(R_MIPS_NONE, 0, a, 0);
+      _globalGotVector.push_back(ga);
+    }
+
+    DEBUG_WITH_TYPE("MipsGOT", {
+      ga->_name = "__got_";
+      ga->_name += a->name();
+      llvm::dbgs() << "[ GOT ] Create " << (isLocal ? "L " : "G ") << a->name()
+                   << "\n";
+    });
+
+    return ga;
+  }
+};
+
+} // end anon namespace
+
+MipsLinkingContext::MipsLinkingContext(llvm::Triple triple)
+    : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
+                                    new MipsTargetHandler(*this))) {}
+
+MipsTargetLayout<Mips32ElELFType> &MipsLinkingContext::getTargetLayout() {
+  auto &layout = getTargetHandler<Mips32ElELFType>().targetLayout();
+  return static_cast<MipsTargetLayout<Mips32ElELFType> &>(layout);
+}
+
+const MipsTargetLayout<Mips32ElELFType> &
+MipsLinkingContext::getTargetLayout() const {
+  auto &layout = getTargetHandler<Mips32ElELFType>().targetLayout();
+  return static_cast<MipsTargetLayout<Mips32ElELFType> &>(layout);
+}
+
+bool MipsLinkingContext::isLittleEndian() const {
+  return Mips32ElELFType::TargetEndianness == llvm::support::little;
+}
+
+#undef LLD_CASE
+#define LLD_CASE(name) .Case(#name, llvm::ELF::name)
+
+ErrorOr<Reference::Kind>
+MipsLinkingContext::relocKindFromString(StringRef str) const {
+  int32_t ret = llvm::StringSwitch<int32_t>(str)
+    LLD_CASE(R_MIPS_NONE)
+    LLD_CASE(R_MIPS_32)
+    LLD_CASE(R_MIPS_HI16)
+    LLD_CASE(R_MIPS_LO16)
+    LLD_CASE(R_MIPS_GOT16)
+    LLD_CASE(R_MIPS_CALL16)
+    LLD_CASE(R_MIPS_JALR)
+    .Default(-1);
+
+  if (ret == -1)
+    return make_error_code(YamlReaderError::illegal_value);
+  return ret;
+}
+
+#undef LLD_CASE
+#define LLD_CASE(name)       \
+  case llvm::ELF::name:      \
+  return std::string(#name);
+
+ErrorOr<std::string>
+MipsLinkingContext::stringFromRelocKind(Reference::Kind kind) const {
+  switch (kind) {
+    LLD_CASE(R_MIPS_NONE)
+    LLD_CASE(R_MIPS_32)
+    LLD_CASE(R_MIPS_HI16)
+    LLD_CASE(R_MIPS_LO16)
+    LLD_CASE(R_MIPS_GOT16)
+    LLD_CASE(R_MIPS_CALL16)
+    LLD_CASE(R_MIPS_JALR)
+  }
+
+  return make_error_code(YamlReaderError::illegal_value);
+}
+
+void MipsLinkingContext::addPasses(PassManager &pm) {
+  switch (getOutputELFType()) {
+  case llvm::ELF::ET_DYN:
+    pm.add(std::unique_ptr<Pass>(new MipsGOTPass(*this)));
+    break;
+  default:
+    llvm_unreachable("Unhandled output file type");
+  }
+
+  ELFLinkingContext::addPasses(pm);
+}

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.h

+//===- lld/ReaderWriter/ELF/Mips/MipsRelocationHandler.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_MIPS_RELOCATION_HANDLER_H
+#define LLD_READER_WRITER_ELF_MIPS_RELOCATION_HANDLER_H
+
+#include "MipsLinkingContext.h"
+
+namespace lld {
+namespace elf {
+
+class MipsTargetHandler;
+
+class MipsTargetRelocationHandler LLVM_FINAL :
+    public TargetRelocationHandler<Mips32ElELFType> {
+public:
+  MipsTargetRelocationHandler(const MipsLinkingContext &context,
+                              const MipsTargetHandler &tH);
+
+  virtual error_code applyRelocation(ELFWriter &,
+                                     llvm::FileOutputBuffer &,
+                                     const lld::AtomLayout &,
+                                     const Reference &) const;
+
+private:
+  const MipsLinkingContext &_context;
+  const MipsTargetHandler &_targetHandler;
+
+  typedef std::vector<const Reference *> PairedRelocationsT;
+  typedef std::unordered_map<const lld::AtomLayout *, PairedRelocationsT>
+  PairedRelocationMapT;
+
+  mutable PairedRelocationMapT _pairedRelocations;
+
+  void savePairedRelocation(const lld::AtomLayout &atom,
+                            const Reference &ref) const;
+  void applyPairedRelocations(ELFWriter &writer, llvm::FileOutputBuffer &buf,
+                              const lld::AtomLayout &atom,
+                              int64_t loAddend) const;
+};
+
+} // elf
+} // lld
+
+#endif

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

+//===- lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp ----------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "MipsTargetHandler.h"
+#include "MipsLinkingContext.h"
+#include "MipsRelocationHandler.h"
+
+#include "lld/ReaderWriter/RelocationHelperFunctions.h"
+
+using namespace lld;
+using namespace elf;
+using namespace llvm::ELF;
+
+namespace {
+
+inline void applyReloc(uint8_t *location, uint32_t result) {
+  auto target = reinterpret_cast<llvm::support::ulittle32_t *>(location);
+  *target = result | *target;
+}
+
+/// \brief Calculate AHL value combines addends from 'hi' and 'lo' relocations.
+inline int64_t calcAHL(int64_t AHI, int64_t ALO) {
+  AHI &= 0xffff;
+  ALO &= 0xffff;
+  return (AHI << 16) + (int16_t)ALO;
+}
+
+/// \brief R_MIPS_32
+/// local/external: word32 S + A (truncate)
+void reloc32(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
+  uint32_t result = (uint32_t)(S + A);
+  applyReloc(location, result);
+}
+
+/// \brief R_MIPS_HI16
+/// local/external: hi16 (AHL + S) - (short)(AHL + S) (truncate)
+/// _gp_disp      : hi16 (AHL + GP - P) - (short)(AHL + GP - P) (verify)
+void relocHi16(uint8_t *location, uint64_t P, uint64_t S, int64_t AHL,
+               uint64_t GP, bool isGPDisp) {
+  int32_t result = 0;
+
+  if (isGPDisp)
+    result = (AHL + GP - P) - (int16_t)(AHL + GP - P);
+  else
+    result = (AHL + S) - (int16_t)(AHL + S);
+
+  result = lld::scatterBits<uint32_t>(result >> 16, 0xffff);
+  applyReloc(location, result);
+}
+
+/// \brief R_MIPS_LO16
+/// local/external: lo16 AHL + S (truncate)
+/// _gp_disp      : lo16 AHL + GP - P + 4 (verify)
+void relocLo16(uint8_t *location, uint64_t P, uint64_t S, int64_t AHL,
+               uint64_t GP, bool isGPDisp) {
+  int32_t result = 0;
+
+  if (isGPDisp)
+    result = AHL + GP - P + 4;
+  else
+    result = AHL + S;
+
+  result = lld::scatterBits<uint32_t>(result, 0xffff);
+  applyReloc(location, result);
+}
+
+/// \brief R_MIPS_GOT16
+/// local/external: rel16 G (verify)
+void relocGOT16(uint8_t *location, uint64_t P, uint64_t S, int64_t AHL,
+                uint64_t GP) {
+  // FIXME (simon): for local sym put high 16 bit of AHL to the GOT
+  int32_t G = (int32_t)(S - GP);
+  int32_t result = lld::scatterBits<uint32_t>(G, 0xffff);
+  applyReloc(location, result);
+}
+
+/// \brief R_MIPS_CALL16
+/// external: rel16 G (verify)
+void relocCall16(uint8_t *location, uint64_t P, uint64_t S, int64_t A,
+                 uint64_t GP) {
+  int32_t G = (int32_t)(S - GP);
+  int32_t result = lld::scatterBits<uint32_t>(G, 0xffff);
+  applyReloc(location, result);
+}
+
+} // end anon namespace
+
+MipsTargetRelocationHandler::MipsTargetRelocationHandler(
+    const MipsLinkingContext &context,
+    const MipsTargetHandler &tH)
+  : _context(context),
+    _targetHandler(tH)
+{}
+
+void
+MipsTargetRelocationHandler::savePairedRelocation(const lld::AtomLayout &atom,
+                                                  const Reference &ref) const {
+  auto pi = _pairedRelocations.find(&atom);
+  if (pi == _pairedRelocations.end())
+    pi = _pairedRelocations.emplace(&atom, PairedRelocationsT()).first;
+
+  pi->second.push_back(&ref);
+}
+
+void MipsTargetRelocationHandler::applyPairedRelocations(
+    ELFWriter &writer, llvm::FileOutputBuffer &buf,
+    const lld::AtomLayout &atom, int64_t loAddend) const {
+  auto pi = _pairedRelocations.find(&atom);
+  if (pi == _pairedRelocations.end())
+    return;
+
+  for (auto ri : pi->second) {
+    uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
+    uint8_t *location = atomContent + ri->offsetInAtom();
+    uint64_t targetVAddress = writer.addressOfAtom(ri->target());
+    uint64_t relocVAddress = atom._virtualAddr + ri->offsetInAtom();
+
+    int64_t ahl = calcAHL(ri->addend(), loAddend);
+
+    switch (ri->kind()) {
+    case R_MIPS_HI16:
+      relocHi16(location, relocVAddress, targetVAddress, ahl,
+                _targetHandler.getGPDispSymAddr(),
+                ri->target()->name() == "_gp_disp");
+      break;
+    case R_MIPS_GOT16:
+      relocGOT16(location, relocVAddress, targetVAddress, ahl,
+                 _targetHandler.getGPDispSymAddr());
+      break;
+    default:
+      llvm_unreachable("Unknown type of paired relocation.");
+    }
+  }
+
+  _pairedRelocations.erase(pi);
+}
+
+error_code MipsTargetRelocationHandler::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();
+
+  switch (ref.kind()) {
+  case R_MIPS_NONE:
+    break;
+  case R_MIPS_32:
+    reloc32(location, relocVAddress, targetVAddress, ref.addend());
+    break;
+  case R_MIPS_HI16:
+    savePairedRelocation(atom, ref);
+    break;
+  case R_MIPS_LO16:
+    relocLo16(location, relocVAddress, targetVAddress, calcAHL(0, ref.addend()),
+              _targetHandler.getGPDispSymAddr(),
+              ref.target()->name() == "_gp_disp");
+    applyPairedRelocations(writer, buf, atom, ref.addend());
+    break;
+  case R_MIPS_GOT16:
+    savePairedRelocation(atom, ref);
+    break;
+  case R_MIPS_CALL16:
+    relocCall16(location, relocVAddress, targetVAddress, ref.addend(),
+                _targetHandler.getGPDispSymAddr());
+    break;
+  case R_MIPS_JALR:
+    // We do not do JALR optimization now.
+    break;
+  case lld::Reference::kindLayoutAfter:
+  case lld::Reference::kindLayoutBefore:
+  case lld::Reference::kindInGroup:
+    break;
+  default : {
+    std::string str;
+    llvm::raw_string_ostream s(str);
+    auto name = _context.stringFromRelocKind(ref.kind());
+    s << "Unhandled relocation: "
+      << (name ? *name : "<unknown>") << " (" << ref.kind() << ")";
+    llvm_unreachable(s.str().c_str());
+  }
+  }
+
+  return error_code::success();
+}

lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h

+//===- lib/ReaderWriter/ELF/Mips/MipsSectionChunks.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_MIPS_SECTION_CHUNKS_H
+#define LLD_READER_WRITER_ELF_MIPS_SECTION_CHUNKS_H
+
+namespace lld {
+namespace elf {
+
+template <typename ELFT> class MipsTargetLayout;
+class MipsLinkingContext;
+
+/// \brief Handle Mips GOT section
+template <class ELFType>
+class MipsGOTSection : public AtomSection<ELFType> {
+public:
+  MipsGOTSection(const MipsLinkingContext &context)
+      : AtomSection<ELFType>(context, ".got", DefinedAtom::typeGOT,
+                             DefinedAtom::permRW_,
+                             MipsTargetLayout<ELFType>::ORDER_GOT),
+        _globalCount(0) {
+    this->_flags |= SHF_MIPS_GPREL;
+    this->_align2 = 4;
+  }
+
+  /// \brief Number of local GOT entries.
+  std::size_t getLocalCount() const {
+    return this->_atoms.size() - _globalCount;
+  }
+
+  /// \brief Number of global GOT entries.
+  std::size_t getGlobalCount() const {
+    return _globalCount;
+  }
+
+  /// \brief Compare two atoms accordingly theirs positions in the GOT.
+  bool compare(const Atom *a, const Atom *b) const {
+    auto ia = _posMap.find(a);
+    auto ib = _posMap.find(b);
+
+    if (ia != _posMap.end() && ib != _posMap.end())
+      return ia->second < ib->second;
+
+    return ia == _posMap.end() && ib != _posMap.end();
+  }
+
+  virtual const lld::AtomLayout &appendAtom(const Atom *atom) {
+    const DefinedAtom *da = dyn_cast<DefinedAtom>(atom);
+
+    const Atom *ta = nullptr;
+    for (const auto &r : *da) {
+      if (r->kind() == llvm::ELF::R_MIPS_32 ||
+          r->kind() == llvm::ELF::R_MIPS_NONE) {
+        ta = r->target();
+        break;
+      }
+    }
+
+    if (ta) {
+      _posMap[ta] = _posMap.size();
+      ++_globalCount;
+    }
+
+    return AtomSection<ELFType>::appendAtom(atom);
+  }
+
+private:
+  /// \brief Number of global GOT entries.
+  std::size_t _globalCount;
+
+  /// \brief Map Atoms to their GOT entry index.
+  llvm::DenseMap<const Atom *, std::size_t> _posMap;
+};
+
+} // elf
+} // lld
+
+#endif

lib/ReaderWriter/ELF/Mips/MipsTarget.h

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

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

+//===- lib/ReaderWriter/ELF/Mips/MipsTargetHandler.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_MIPS_TARGET_HANDLER_H
+#define LLD_READER_WRITER_ELF_MIPS_TARGET_HANDLER_H
+
+#include "DefaultTargetHandler.h"
+#include "MipsLinkingContext.h"
+#include "MipsRelocationHandler.h"
+#include "MipsSectionChunks.h"
+#include "TargetLayout.h"
+
+namespace lld {
+namespace elf {
+
+/// \brief TargetLayout for Mips
+template <class ELFType>
+class MipsTargetLayout LLVM_FINAL : public TargetLayout<ELFType> {
+public:
+  MipsTargetLayout(const MipsLinkingContext &ctx)
+      : TargetLayout<ELFType>(ctx),
+        _gotSection(new (_alloc) MipsGOTSection<ELFType>(ctx)) {}
+
+  const MipsGOTSection<ELFType> &getGOTSection() const {
+    return *_gotSection;
+  }
+
+  virtual AtomSection<ELFType> *
+  createSection(StringRef name, int32_t type,
+                DefinedAtom::ContentPermissions permissions,
+                Layout::SectionOrder order) {
+    if (type == DefinedAtom::typeGOT)
+      return _gotSection;
+    return DefaultLayout<ELFType>::createSection(name, type, permissions,
+                                                 order);
+  }
+
+private:
+  llvm::BumpPtrAllocator _alloc;
+  MipsGOTSection<ELFType> *_gotSection;
+};
+
+/// \brief TargetHandler for Mips
+class MipsTargetHandler LLVM_FINAL
+    : public DefaultTargetHandler<Mips32ElELFType> {
+public:
+  MipsTargetHandler(MipsLinkingContext &targetInfo);
+
+  uint64_t getGPDispSymAddr() const;
+
+  virtual MipsTargetLayout<Mips32ElELFType> &targetLayout();
+  virtual const MipsTargetRelocationHandler &getRelocationHandler() const;
+  virtual LLD_UNIQUE_BUMP_PTR(DynamicTable<Mips32ElELFType>)
+  createDynamicTable();
+  virtual LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<Mips32ElELFType>)
+  createDynamicSymbolTable();
+  virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &result);
+  virtual void finalizeSymbolValues();
+
+private:
+  llvm::BumpPtrAllocator _alloc;
+  MipsTargetLayout<Mips32ElELFType> _targetLayout;
+  MipsTargetRelocationHandler _relocationHandler;
+  AtomLayout *_gotSymAtom;
+  AtomLayout *_gpDispSymAtom;
+};
+
+} // end namespace elf
+} // end namespace lld
+
+#endif

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp

+//===- lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp --------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "File.h"
+#include "MipsLinkingContext.h"
+#include "MipsTargetHandler.h"
+
+using namespace lld;
+using namespace elf;
+
+namespace {
+
+class MipsDynamicSymbolTable : public DynamicSymbolTable<Mips32ElELFType> {
+public:
+  MipsDynamicSymbolTable(const MipsLinkingContext &context)
+      : DynamicSymbolTable<Mips32ElELFType>(
+            context, ".dynsym",
+            DefaultLayout<Mips32ElELFType>::ORDER_DYNAMIC_SYMBOLS),
+        _layout(context.getTargetLayout()) {}
+
+  virtual void sortSymbols() {
+    std::stable_sort(_symbolTable.begin(), _symbolTable.end(),
+                     [this](const SymbolEntry & A, const SymbolEntry & B) {
+      if (A._symbol.getBinding() != STB_GLOBAL &&
+          B._symbol.getBinding() != STB_GLOBAL)
+        return A._symbol.getBinding() < B._symbol.getBinding();
+
+      return _layout.getGOTSection().compare(A._atom, B._atom);
+    });
+  }
+
+private:
+  const MipsTargetLayout<Mips32ElELFType> &_layout;
+};
+
+class MipsDynamicTable : public DynamicTable<Mips32ElELFType> {
+public:
+  MipsDynamicTable(const MipsLinkingContext &context)
+      : DynamicTable<Mips32ElELFType>(
+            context, ".dynamic",
+            DefaultLayout<Mips32ElELFType>::ORDER_DYNAMIC), 
+        _layout(context.getTargetLayout()) {}
+
+  virtual void createDefaultEntries() {
+    DynamicTable<Mips32ElELFType>::createDefaultEntries();
+
+    Elf_Dyn dyn;
+
+    // Version id for the Runtime Linker Interface.
+    dyn.d_un.d_val = 1;
+    dyn.d_tag = DT_MIPS_RLD_VERSION;
+    addEntry(dyn);
+
+    // MIPS flags.
+    dyn.d_un.d_val = RHF_NOTPOT;
+    dyn.d_tag = DT_MIPS_FLAGS;
+    addEntry(dyn);
+
+    // The base address of the segment.
+    dyn.d_un.d_ptr = 0;
+    dyn.d_tag = DT_MIPS_BASE_ADDRESS;
+    addEntry(dyn);
+
+    // Number of local global offset table entries.
+    dyn.d_un.d_val = 0;
+    dyn.d_tag = DT_MIPS_LOCAL_GOTNO;
+    _dt_localgot = addEntry(dyn);
+
+    // Number of entries in the .dynsym section.
+    dyn.d_un.d_val = 0;
+    dyn.d_tag = DT_MIPS_SYMTABNO;
+    _dt_symtabno = addEntry(dyn);
+
+    // The index of the first dynamic symbol table entry that corresponds
+    // to an entry in the global offset table.
+    dyn.d_un.d_val = 0;
+    dyn.d_tag = DT_MIPS_GOTSYM;
+    _dt_gotsym = addEntry(dyn);
+
+    // Address of the .got section.
+    dyn.d_un.d_val = 0;
+    dyn.d_tag = DT_PLTGOT;
+    _dt_pltgot = addEntry(dyn);
+  }
+
+  virtual void updateDynamicTable() {
+    DynamicTable<Mips32ElELFType>::updateDynamicTable();
+
+    auto &got = _layout.getGOTSection();
+
+    _entries[_dt_symtabno].d_un.d_val = getSymbolTable()->size();
+    _entries[_dt_gotsym].d_un.d_val =
+        getSymbolTable()->size() - got.getGlobalCount();
+    _entries[_dt_localgot].d_un.d_val = got.getLocalCount();
+    _entries[_dt_pltgot].d_un.d_ptr =
+        _layout.findOutputSection(".got")->virtualAddr();
+  }
+
+private:
+  const MipsTargetLayout<Mips32ElELFType> &_layout;
+
+  std::size_t _dt_symtabno;
+  std::size_t _dt_localgot;
+  std::size_t _dt_gotsym;
+  std::size_t _dt_pltgot;
+};
+
+}
+
+MipsTargetHandler::MipsTargetHandler(MipsLinkingContext &context)
+  : DefaultTargetHandler(context),
+    _targetLayout(context),
+    _relocationHandler(context, *this)
+{}
+
+uint64_t MipsTargetHandler::getGPDispSymAddr() const {
+  return _gpDispSymAtom ? _gpDispSymAtom->_virtualAddr : 0;
+}
+
+MipsTargetLayout<Mips32ElELFType> &MipsTargetHandler::targetLayout() {
+  return _targetLayout;
+}
+
+const MipsTargetRelocationHandler &
+MipsTargetHandler::getRelocationHandler() const {
+  return _relocationHandler;
+}
+
+LLD_UNIQUE_BUMP_PTR(DynamicTable<Mips32ElELFType>)
+MipsTargetHandler::createDynamicTable() {
+  return LLD_UNIQUE_BUMP_PTR(DynamicTable<Mips32ElELFType>)(
+      new (_alloc) MipsDynamicTable(
+          static_cast<const MipsLinkingContext &>(_context)));
+}
+
+LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<Mips32ElELFType>)
+MipsTargetHandler::createDynamicSymbolTable() {
+  return LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<Mips32ElELFType>)(
+      new (_alloc) MipsDynamicSymbolTable(
+          static_cast<const MipsLinkingContext &>(_context)));
+}
+
+bool MipsTargetHandler::createImplicitFiles(
+    std::vector<std::unique_ptr<File>> &result) {
+  typedef CRuntimeFile<Mips32ElELFType> RFile;
+  auto file = std::unique_ptr<RFile>(new RFile(_context, "MIPS runtime file"));
+
+  if (_context.isDynamic()) {
+    file->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
+    file->addAbsoluteAtom("_gp_disp");
+  }
+  result.push_back(std::move(file));
+  return true;
+}
+
+void MipsTargetHandler::finalizeSymbolValues() {
+  DefaultTargetHandler<Mips32ElELFType>::finalizeSymbolValues();
+
+  if (_context.isDynamic()) {
+    auto gotSection = _targetLayout.findOutputSection(".got");
+
+    auto gotAtomIter = _targetLayout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
+    assert(gotAtomIter != _targetLayout.absoluteAtoms().end());
+    _gotSymAtom = (*gotAtomIter);
+    _gotSymAtom->_virtualAddr = gotSection ? gotSection->virtualAddr() : 0;
+
+    auto gpDispAtomIter = _targetLayout.findAbsoluteAtom("_gp_disp");
+    assert(gpDispAtomIter != _targetLayout.absoluteAtoms().end());
+    _gpDispSymAtom = (*gpDispAtomIter);
+    _gpDispSymAtom->_virtualAddr =
+        gotSection ? gotSection->virtualAddr() + 0x7FF0 : 0;
+  }
+}

lib/ReaderWriter/ELF/OutputELFWriter.h

if (sec->name() != ".eh_frame")
       continue;
     _ehFrameHeader.reset(new (_alloc) EHFrameHeader<ELFT>(
         _context, ".eh_frame_hdr", DefaultLayout<ELFT>::ORDER_EH_FRAMEHDR));
     _layout->addSection(_ehFrameHeader.get());
     break;
   }
 
   if (_context.isDynamic()) {
-    _dynamicTable.reset(new (_alloc) DynamicTable<ELFT>(
-        _context, ".dynamic", DefaultLayout<ELFT>::ORDER_DYNAMIC));
+    _dynamicTable = std::move(_targetHandler.createDynamicTable());
     _dynamicStringTable.reset(new (_alloc) StringTable<ELFT>(
         _context, ".dynstr", DefaultLayout<ELFT>::ORDER_DYNAMIC_STRINGS, true));
-    _dynamicSymbolTable.reset(new (_alloc) DynamicSymbolTable<ELFT>(
-        _context, ".dynsym", DefaultLayout<ELFT>::ORDER_DYNAMIC_SYMBOLS));
+    _dynamicSymbolTable = std::move(_targetHandler.createDynamicSymbolTable());
     _hashTable.reset(new (_alloc) HashSection<ELFT>(
         _context, ".hash", DefaultLayout<ELFT>::ORDER_HASH));
     // Set the hash table in the dynamic symbol table so that the entries in the
     // hash table can be created
     _dynamicSymbolTable->setHashTable(_hashTable.get());
     _hashTable->setSymbolTable(_dynamicSymbolTable.get());
     _layout->addSection(_dynamicTable.get());
     _layout->addSection(_dynamicStringTable.get());

lib/ReaderWriter/ELF/SectionChunks.h

for (auto si : _strings) {
     memcpy(dest, "", 1);
     dest += 1;
   }
 }
 
 /// \brief The SymbolTable class represents the symbol table in a ELF file
 template<class ELFT>
 class SymbolTable : public Section<ELFT> {
   typedef typename llvm::object::ELFDataTypeTypedefHelper<ELFT>::Elf_Addr
       Elf_Addr;
+public:
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
 
-  struct SymbolEntry {
-    SymbolEntry(const Atom *a, const Elf_Sym &sym,
-                const lld::AtomLayout *layout)
-        : _atom(a), _atomLayout(layout), _symbol(sym) {}
-
-    const Atom *_atom;
-    const lld::AtomLayout *_atomLayout;
-    Elf_Sym _symbol;
-  };
-
-public:
   SymbolTable(const ELFLinkingContext &context, const char *str, int32_t order);
 
   /// \brief set the number of entries that would exist in the symbol
   /// table for the current link
   void setNumEntries(int64_t numEntries) const {
     if (_stringSection)
       _stringSection->setNumEntries(numEntries);
   }
 
+  /// \brief return number of entries
+  std::size_t size() const {
+    return _symbolTable.size();
+  }
+
   void addSymbol(const Atom *atom, int32_t sectionIndex, uint64_t addr = 0,
                  const lld::AtomLayout *layout = nullptr);
 
   /// \brief Get the symbol table index for an Atom. If it's not in the symbol
   /// table, return STN_UNDEF.
   uint32_t getSymbolTableIndex(const Atom *a) const {
     for (size_t i = 0, e = _symbolTable.size(); i < e; ++i)
       if (_symbolTable[i]._atom == a)
public:
 
   virtual void write(ELFWriter *writer, llvm::FileOutputBuffer &buffer);
 
   void setStringSection(StringTable<ELFT> *s) { _stringSection = s; }
 
   StringTable<ELFT> *getStringTable() const { return _stringSection; }
 
 protected:
+  struct SymbolEntry {
+    SymbolEntry(const Atom *a, const Elf_Sym &sym,
+                const lld::AtomLayout *layout)
+        : _atom(a), _atomLayout(layout), _symbol(sym) {}
+
+    const Atom *_atom;
+    const lld::AtomLayout *_atomLayout;
+    Elf_Sym _symbol;
+  };
+
   llvm::BumpPtrAllocator _symbolAllocate;
   StringTable<ELFT> *_stringSection;
   std::vector<SymbolEntry> _symbolTable;
 };
 
 /// ELF Symbol Table
 template <class ELFT>
 SymbolTable<ELFT>::SymbolTable(const ELFLinkingContext &context,

 private:
   std::vector<std::pair<const DefinedAtom *, const Reference *> > _relocs;
   const DynamicSymbolTable<ELFT> *_symbolTable;
 };
 
 template <class ELFT> class HashSection;
 
 template <class ELFT> class DynamicTable : public Section<ELFT> {
+public:
   typedef llvm::object::Elf_Dyn_Impl<ELFT> Elf_Dyn;
   typedef std::vector<Elf_Dyn> EntriesT;
 
-public:
   DynamicTable(const ELFLinkingContext &context, StringRef str, int32_t order)
       : Section<ELFT>(context, str) {
     this->setOrder(order);
     this->_entSize = sizeof(Elf_Dyn);
     this->_align2 = llvm::alignOf<Elf_Dyn>();
     // Reserve space for the DT_NULL entry.
     this->_fsize = sizeof(Elf_Dyn);
     this->_msize = sizeof(Elf_Dyn);
     this->_type = SHT_DYNAMIC;
     this->_flags = SHF_ALLOC;
     _layout = &context.getTargetHandler<ELFT>().targetLayout();
   }
 
   range<typename EntriesT::iterator> entries() { return _entries; }
 
   /// \returns the index of the entry.
   std::size_t addEntry(Elf_Dyn e) {
     _entries.push_back(e);
     this->_fsize = (_entries.size() * sizeof(Elf_Dyn)) + sizeof(Elf_Dyn);
     this->_msize = this->_fsize;
     return _entries.size() - 1;
   }
 
   void write(ELFWriter *writer, llvm::FileOutputBuffer &buffer) {
     uint8_t *chunkBuffer = buffer.getBufferStart();
     uint8_t *dest = chunkBuffer + this->fileOffset();
     // Add the null entry.
     Elf_Dyn d;
     d.d_tag = 0;
     d.d_un.d_val = 0;
     _entries.push_back(d);
     std::memcpy(dest, _entries.data(), this->_fsize);
   }
 
-  void createDefaultEntries() {
+  virtual void createDefaultEntries() {
     Elf_Dyn dyn;
     dyn.d_un.d_val = 0;
 
     dyn.d_tag = DT_HASH;
     _dt_hash = addEntry(dyn);
     dyn.d_tag = DT_STRTAB;
     _dt_strtab = addEntry(dyn);
     dyn.d_tag = DT_SYMTAB;
if (this->_parent) {
       this->_parent->setLink(this->_link);
     }
   }
 
   void setSymbolTable(DynamicSymbolTable<ELFT> *dynsym) {
     _dynamicSymbolTable = dynsym;
   }
 
+  const DynamicSymbolTable<ELFT> *getSymbolTable() const {
+    return _dynamicSymbolTable;
+  }
+
   void setHashTable(HashSection<ELFT> *hsh) { _hashTable = hsh; }
 
-  void updateDynamicTable() {
+  virtual void updateDynamicTable() {
     StringTable<ELFT> *dynamicStringTable =
         _dynamicSymbolTable->getStringTable();
     _entries[_dt_hash].d_un.d_val = _hashTable->virtualAddr();
     _entries[_dt_strtab].d_un.d_val = dynamicStringTable->virtualAddr();
     _entries[_dt_symtab].d_un.d_val = _dynamicSymbolTable->virtualAddr();
     _entries[_dt_strsz].d_un.d_val = dynamicStringTable->memSize();
     _entries[_dt_syment].d_un.d_val = _dynamicSymbolTable->getEntSize();
     auto finiArray = _layout->findOutputSection(".fini_array");
if (_layout->hasPLTRelocationTable()) {
       auto relaTbl = _layout->getPLTRelocationTable();
       _entries[_dt_jmprel].d_un.d_val = relaTbl->virtualAddr();
       _entries[_dt_pltrelsz].d_un.d_val = relaTbl->memSize();
       auto gotplt = _layout->findOutputSection(".got.plt");
       _entries[_dt_pltgot].d_un.d_val = gotplt->virtualAddr();
     }
   }
 
-private:
+protected:
   EntriesT _entries;
+
+private:
   std::size_t _dt_hash;
   std::size_t _dt_strtab;
   std::size_t _dt_symtab;
   std::size_t _dt_rela;
   std::size_t _dt_relasz;
   std::size_t _dt_relaent;
   std::size_t _dt_strsz;
   std::size_t _dt_syment;

lib/ReaderWriter/ELF/TargetHandler.h

 
 #ifndef LLD_READER_WRITER_ELF_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_TARGET_HANDLER_H
 
 #include "Layout.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/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;
 
 /// \brief The target registers a set of handlers for overriding target specific
public:
 
   /// \brief Finalize the symbol values
   virtual void finalizeSymbolValues() = 0;
 
   /// \brief allocate Commons, some architectures may move small common
   /// symbols over to small data, this would also be used
   virtual void allocateCommons() = 0;
 
+  /// \brief create dynamic table
+  virtual LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>) createDynamicTable() = 0;
+
+  /// \brief create dynamic symbol table
+  virtual LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)
+  createDynamicSymbolTable() = 0;
+
 protected:
   const ELFLinkingContext &_context;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

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 "Hexagon/HexagonTarget.h"
+#include "Mips/MipsTarget.h"
 #include "PPC/PPCTarget.h"
 #include "X86/X86Target.h"
 #include "X86_64/X86_64Target.h"
 
 #endif

test/elf/Mips/Inputs/dynobj.c

+// clang -O0 -EL -fPIC -target mipsel-linux-gnu -c dynobj.c -o dynobj.o
+int xyz(const char *);
+int abc(const char *);
+
+int bar(void)
+{
+  return 1;
+}
+
+int foo(void)
+{
+  bar();
+  return xyz("str1") + abc("str2");
+}

test/elf/Mips/dynlib-dynamic.test

+# Check MIPS specific tags in the dynamic table.
+RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec \
+RUN:     -o %t %p/Inputs/dynobj.o
+RUN: llvm-readobj -dynamic-table %t | FileCheck %s
+
+CHECK: Format: ELF32-mips
+CHECK: Arch: mipsel
+CHECK: AddressSize: 32bit
+CHECK: LoadName: 
+CHECK: DynamicSection [ (15 entries)
+CHECK:   Tag        Type                 Name/Value
+CHECK:   0x00000004 HASH                 0xE0
+CHECK:   0x00000005 STRTAB               0x158
+CHECK:   0x00000006 SYMTAB               0x108
+CHECK:   0x0000000A STRSZ                17 (bytes)
+CHECK:   0x0000000B SYMENT               16 (bytes)
+CHECK:   0x0000001A FINI_ARRAY           0x0
+CHECK:   0x0000001C FINI_ARRAYSZ         0 (bytes)
+CHECK:   0x70000001 MIPS_RLD_VERSION     1
+CHECK:   0x70000005 MIPS_FLAGS           0x2
+CHECK:   0x70000006 MIPS_BASE_ADDRESS    0x0
+CHECK:   0x7000000A MIPS_LOCAL_GOTNO     4
+CHECK:   0x70000011 MIPS_SYMTABNO        5
+CHECK:   0x70000013 MIPS_GOTSYM          0x2
+CHECK:   0x00000003 PLTGOT               0x1000
+CHECK:   0x00000000 NULL                 0x0
+CHECK: ]

test/elf/Mips/dynlib-dynsym.test

+# Check sorting of .dynsym content accordingly to .got section.
+RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec \
+RUN:     -o %t %p/Inputs/dynobj.o
+RUN: llvm-readobj -dyn-symbols %t | FileCheck -check-prefix=CHECK-DYN %s
+
+RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec \
+RUN:     --output-filetype=yaml -o %t %p/Inputs/dynobj.o
+RUN: FileCheck -check-prefix=CHECK-GOT %s < %t
+
+CHECK-DYN: Format: ELF32-mips
+CHECK-DYN: Arch: mipsel
+CHECK-DYN: AddressSize: 32bit
+CHECK-DYN: LoadName: 
+CHECK-DYN: DynamicSymbols [
+CHECK-DYN:   Symbol {
+CHECK-DYN:     Name: @ (0)
+CHECK-DYN:     Value: 0x0
+CHECK-DYN:     Size: 0
+CHECK-DYN:     Binding: Local (0x0)
+CHECK-DYN:     Type: None (0x0)
+CHECK-DYN:     Other: 0
+CHECK-DYN:     Section:  (0x0)
+CHECK-DYN:   }
+CHECK-DYN:   Symbol {
+CHECK-DYN:     Name: foo@ (5)
+CHECK-DYN:     Value: 0x194
+CHECK-DYN:     Size: 156
+CHECK-DYN:     Binding: Global (0x1)
+CHECK-DYN:     Type: Function (0x2)
+CHECK-DYN:     Other: 0
+CHECK-DYN:     Section: .text (0x4)
+CHECK-DYN:   }
+CHECK-DYN:   Symbol {
+CHECK-DYN:     Name: bar@ (1)
+CHECK-DYN:     Value: 0x170
+CHECK-DYN:     Size: 36
+CHECK-DYN:     Binding: Global (0x1)
+CHECK-DYN:     Type: Function (0x2)
+CHECK-DYN:     Other: 0
+CHECK-DYN:     Section: .text (0x4)
+CHECK-DYN:   }
+CHECK-DYN:   Symbol {
+CHECK-DYN:     Name: xyz@ (9)
+CHECK-DYN:     Value: 0x0
+CHECK-DYN:     Size: 0
+CHECK-DYN:     Binding: Global (0x1)
+CHECK-DYN:     Type: None (0x0)
+CHECK-DYN:     Other: 0
+CHECK-DYN:     Section:  (0x0)
+CHECK-DYN:   }
+CHECK-DYN:   Symbol {
+CHECK-DYN:     Name: abc@ (13)
+CHECK-DYN:     Value: 0x0
+CHECK-DYN:     Size: 0
+CHECK-DYN:     Binding: Global (0x1)
+CHECK-DYN:     Type: None (0x0)
+CHECK-DYN:     Other: 0
+CHECK-DYN:     Section:  (0x0)
+CHECK-DYN:   }
+CHECK-DYN: ]
+
+CHECK-GOT:   - type:            got
+CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
+CHECK-GOT:     alignment:       2^2
+CHECK-GOT:     section-choice:  custom-required
+CHECK-GOT:     section-name:    .got
+CHECK-GOT:     permissions:     rw-
+CHECK-GOT:   - type:            got
+CHECK-GOT:     content:         [ 00, 00, 00, 80 ]
+CHECK-GOT:     alignment:       2^2
+CHECK-GOT:     section-choice:  custom-required
+CHECK-GOT:     section-name:    .got
+CHECK-GOT:     permissions:     rw-
+CHECK-GOT:   - ref-name:        L004
+CHECK-GOT:     type:            got
+CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
+CHECK-GOT:     alignment:       2^2
+CHECK-GOT:     section-choice:  custom-required
+CHECK-GOT:     section-name:    .got
+CHECK-GOT:     permissions:     rw-
+CHECK-GOT:   - ref-name:        L006
+CHECK-GOT:     type:            got
+CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
+CHECK-GOT:     alignment:       2^2
+CHECK-GOT:     section-choice:  custom-required
+CHECK-GOT:     section-name:    .got
+CHECK-GOT:     permissions:     rw-
+CHECK-GOT:   - ref-name:        L003
+CHECK-GOT:     type:            got
+CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
+CHECK-GOT:     alignment:       2^2
+CHECK-GOT:     section-choice:  custom-required
+CHECK-GOT:     section-name:    .got
+CHECK-GOT:     permissions:     rw-
+CHECK-GOT:     references:
+CHECK-GOT:       - kind:            R_MIPS_32
+CHECK-GOT:         offset:          0
+CHECK-GOT:         target:          bar
+CHECK-GOT:   - ref-name:        L005
+CHECK-GOT:     type:            got
+CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
+CHECK-GOT:     alignment:       2^2
+CHECK-GOT:     section-choice:  custom-required
+CHECK-GOT:     section-name:    .got
+CHECK-GOT:     permissions:     rw-
+CHECK-GOT:   - ref-name:        L007
+CHECK-GOT:     type:            got
+CHECK-GOT:     content:         [ 00, 00, 00, 00 ]
+CHECK-GOT:     alignment:       2^2
+CHECK-GOT:     section-choice:  custom-required
+CHECK-GOT:     section-name:    .got
+CHECK-GOT:     permissions:     rw-
+CHECK-GOT:   - ref-name:        L002
+CHECK-GOT:     alignment:       2^4
+CHECK-GOT:     references:
+CHECK-GOT:       - kind:            layout-after
+CHECK-GOT:         offset:          0
+CHECK-GOT:         target:          bar

test/elf/Mips/dynlib-fileheader.test

+RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec \
+RUN:     -o %t %p/Inputs/dynobj.o
+RUN: llvm-readobj -file-headers %t | FileCheck %s
+
+CHECK: Format: ELF32-mips
+CHECK: Arch: mipsel
+CHECK: AddressSize: 32bit
+CHECK: LoadName: 
+CHECK: ElfHeader {
+CHECK:   Ident {
+CHECK:    Magic: (7F 45 4C 46)
+CHECK:    Class: 32-bit (0x1)
+CHECK:    DataEncoding: LittleEndian (0x1)
+CHECK:    FileVersion: 1
+CHECK:    OS/ABI: SystemV (0x0)
+CHECK:    ABIVersion: 0
+CHECK:    Unused: (00 00 00 00 00 00 00)
+CHECK:  }
+CHECK:  Type: SharedObject (0x3)
+CHECK:  Machine: EM_MIPS (0x8)
+CHECK:  Version: 1
+CHECK:  Entry: 0x170
+CHECK:  ProgramHeaderOffset: 0x34
+CHECK:  SectionHeaderOffset: 0x21C8
+CHECK:  Flags [ (0x0)
+CHECK:  ]
+CHECK:  HeaderSize: 52
+CHECK:  ProgramHeaderEntrySize: 32
+CHECK:  ProgramHeaderCount: 5
+CHECK:  SectionHeaderEntrySize: 40
+CHECK:  SectionHeaderCount: 16
+CHECK:  StringTableSectionIndex: 13
+CHECK:}

test/elf/Mips/dynlib-gotsym.test

+# Check _gp_disp and GOT_OFFSET_TABLE value
+RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec \
+RUN:     -o %t %p/Inputs/dynobj.o
+RUN: llvm-objdump -section-headers -t %t | FileCheck %s
+
+CHECK: Idx Name          Size      Address          Type
+CHECK:   7 .got          0000001c 0000000000001000 DATA 
+
+CHECK: SYMBOL TABLE:
+CHECK: 00001000 g       *ABS*  00000000 _GLOBAL_OFFSET_TABLE_
+CHECK: 00008ff0 g       *ABS*  00000000 _gp_disp

test/elf/phdr.test

 I386-NEXT:     Offset: 0x1FC
 I386-NEXT:     VirtualAddress: 0x1FC
 I386-NEXT:     PhysicalAddress: 0x1FC
 I386-NEXT:     FileSize: 64
 I386-NEXT:     MemSize: 64
 I386-NEXT:     Flags [ (0x4)
 I386-NEXT:       PF_R (0x4)
 I386-NEXT:     ]
-I386-NEXT:     Alignment: 4
+I386-NEXT:     Alignment: 2
 I386-NEXT:   }
 
 X86_64: LOAD off    0x0000000000000000
 X86_64: LOAD off    0x0000000000001000