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

39

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

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

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

lib/ReaderWriter/ELF/Mips/MipsGOT.cpp

90

Why 2 + ?

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

60

not the right place for holding to the got.

71–73

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

120–121

add else case and llvm_unreachable.

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

23–31

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

27–29

not sure what this comment is addressing.

31–32

the comments are describing parameters that are different in names.

39–40

the comments are describing parameters that are different in names.

44

nit pick. empty lines

72–74

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

83–84

the comments are describing parameters that are different in names.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.h

42–46

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

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp

27

Didnt find a call to this function.

28–29

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

171

assert if these atoms are not found.

173

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

lib/ReaderWriter/ELF/SectionChunks.h

610

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.

626

unrelated change ?

993

same as previous.

1022–1024

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

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

lib/ReaderWriter/ELF/Mips/MipsGOT.cpp

69

s/auto/bool/

79

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

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

25

Why macro? Can it be an inline function?

33

In LLD local variables usually start with a lowercase letter.

188

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

27

2^16 is too large. Typo of 4?

lib/ReaderWriter/ELF/Mips/MipsTarget.h

10

Do you really need this file?

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

27

"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

OK

17

Agree. I will rename it to the Mips32ElELFType.

lib/ReaderWriter/ELF/Mips/MipsGOT.cpp

69

OK

79

OK

90

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

OK

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

60

OK. I will fix that.

71–73

OK. I will fix that.

120–121

OK

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

23–31

OK. I will fix that.

39

OK. I will fix that.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

25

I will replace this macros by inline function.

27–29

OK. I will reformat comments for relocation handling function.

31–32

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

33

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.

39–40

OK. I will fix that,

44

OK

72–74

OK. I will fix that.

83–84

OK. I will fix that.

188

OK. I will fix that.

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.h

42–46

OK

lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h

27

OK. I will fix that.

lib/ReaderWriter/ELF/Mips/MipsTarget.h

10

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

27

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

28–29

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.

171

OK

173

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

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

27

OK. I will fix that.

lib/ReaderWriter/ELF/SectionChunks.h

610

OK. I will fix that.

626

Yes. I will fix that.

993

OK. I will fix that.

1022–1024

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

OK. I will fix that.

[atanasyan]

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

18

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

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

39

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

39

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

39

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

39

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 ↗

(On Diff #6004)

You may want to remove this duplicate function.

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp

107

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

60

eti -> ctx?

125

You might want to add llvm_unreachable for other cases.

138

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

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

25

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

[atanasyan]

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

125

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

25

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/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(llvm::BumpPtrAllocator &alloc,
+                     StringRef name, int32_t order) {
+    return LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>)(
+        new (alloc) DynamicTable<ELFT>(TargetHandler<ELFT>::_context,
+                                       name, order));
+  }
+
+  /// \brief create dynamic symbol table
+  LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)
+  createDynamicSymbolTable(llvm::BumpPtrAllocator &alloc,
+                           StringRef name, int32_t order) {
+    return LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)(
+        new (alloc) DynamicSymbolTable<ELFT>(TargetHandler<ELFT>::_context,
+                                             name, order));
+  }
 };
 } // 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
+  MipsGOT.cpp
+  MipsLinkingContext.cpp
+  MipsRelocationHandler.cpp
+  MipsTargetHandler.cpp
+  )
+
+target_link_libraries(lldMipsELFTarget
+  lldCore
+  )

lib/ReaderWriter/ELF/Mips/MipsELFTypes.h

+//===- lld/ReaderWriter/ELF/Mips/MipsELFTypes.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_ELF_TYPES_H
+#define LLD_READER_WRITER_ELF_MIPS_ELF_TYPES_H
+
+#include "llvm/Object/ELFTypes.h"
+
+namespace lld {
+namespace elf {
+
+typedef llvm::object::ELFType<llvm::support::little, 2, false> MipsELFType;
+
+} // elf
+} // lld
+
+#endif

lib/ReaderWriter/ELF/Mips/MipsGOT.h

+//===- lib/ReaderWriter/ELF/Mips/MipsGOT.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_GOT_H
+#define LLD_READER_WRITER_ELF_MIPS_GOT_H
+
+#include "lld/ReaderWriter/Simple.h"
+
+#include "llvm/ADT/DenseMap.h"
+
+namespace lld {
+namespace elf {
+
+class GOTAtom;
+class MipsLinkingContext;
+
+class MipsGOT {
+public:
+  MipsGOT(const MipsLinkingContext &context);
+
+  /// \brief Find or create a new GOT entry for the specified atom.
+  const GOTAtom *getEntry(const Atom *a);
+
+  /// \brief Number of local GOT entries.
+  std::size_t getLocalCount() const;
+
+  /// \brief Number of global GOT entries.
+  std::size_t getGlobalCount() const;
+
+  /// \brief Add allocated GOT entries to the file.
+  void addAtoms(MutableFile &mf);
+
+  /// \brief Compare two atoms accordingly theirs positions in the GOT.
+  bool compare(const Atom *a, const Atom *b) const;
+
+private:
+  /// \brief Allocator used for GOT entries creation.
+  llvm::BumpPtrAllocator _alloc;
+
+  /// \brief file to hold GOT entries.
+  SimpleFile _file;
+
+  /// \brief GOT header entries.
+  GOTAtom *_got0;
+  GOTAtom *_got1;
+
+  /// \brief Map Atoms to their GOT entries.
+  llvm::DenseMap<const Atom *, GOTAtom *> _gotMap;
+
+  /// \brief Map Atoms to their GOT entry index.
+  llvm::DenseMap<const Atom *, std::size_t> _posMap;
+
+  /// \brief the list of local GOT atoms.
+  std::vector<GOTAtom *> _localGotVector;
+
+  /// \brief the list of global GOT atoms.
+  std::vector<GOTAtom *> _globalGotVector;
+};
+
+} // elf
+} // lld
+
+#endif

lib/ReaderWriter/ELF/Mips/MipsGOT.cpp

+//===- lib/ReaderWriter/ELF/Mips/MipsGOT.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 "MipsGOT.h"
+#include "MipsLinkingContext.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);
+  }
+};
+
+}
+
+MipsGOT::MipsGOT(const MipsLinkingContext &context)
+    : _file(context, "MipsGOTPassFile"),
+      _got0(new (_alloc) MipsGOT0Atom(_file)),
+      _got1(new (_alloc) MipsGOTModulePointerAtom(_file))
+{}
+
+const GOTAtom *MipsGOT::getEntry(const Atom *a) {
+  auto got = _gotMap.find(a);
+  if (got != _gotMap.end())
+    return got->second;
+
+  const DefinedAtom *da = dyn_cast<DefinedAtom>(a);
+  auto isLocal = da && da->scope() == Atom::scopeTranslationUnit;
+
+  auto ga = new (_alloc) MipsGOT0Atom(_file);
+  _gotMap[a] = ga;
+  if (isLocal)
+    _localGotVector.push_back(ga);
+  else {
+    _globalGotVector.push_back(ga);
+    _posMap[a] = _globalGotVector.size() - 1;
+  }
+#ifndef NDEBUG
+  ga->_name = "__got_";
+  ga->_name += a->name();
+  DEBUG_WITH_TYPE("GOT", llvm::dbgs() << "[ GOT ] Create "
+                                      << (isLocal ? "L " : "G ")
+                                      << a->name() << "\n");
+#endif
+  return ga;
+}
+
+std::size_t MipsGOT::getLocalCount() const {
+  return 2 + _localGotVector.size();
+}
+
+std::size_t MipsGOT::getGlobalCount() const {
+  return _globalGotVector.size();
+}
+
+void MipsGOT::addAtoms(MutableFile &mf) {
+  uint64_t ordinal = 0;
+
+#ifndef NDEBUG
+  DEBUG_WITH_TYPE("GOT", llvm::dbgs() << "[ GOT ] Adding GOT header\n");
+#endif
+  _got0->setOrdinal(ordinal++);
+  _got1->setOrdinal(ordinal++);
+  mf.addAtom(*_got0);
+  mf.addAtom(*_got1);
+
+  for (auto &got : _localGotVector) {
+#ifndef NDEBUG
+    DEBUG_WITH_TYPE("GOT", llvm::dbgs() << "[ GOT ] Adding L "
+                                        << got->name() << "\n");
+#endif
+    got->setOrdinal(ordinal++);
+    mf.addAtom(*got);
+  }
+
+  for (auto &got : _globalGotVector) {
+#ifndef NDEBUG
+    DEBUG_WITH_TYPE("GOT", llvm::dbgs() << "[ GOT ] Adding G "
+                                        << got->name() << "\n");
+#endif
+    got->setOrdinal(ordinal++);
+    mf.addAtom(*got);
+  }
+}
+
+bool MipsGOT::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();
+}

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 "MipsGOT.h"
+
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+
+namespace lld {
+namespace elf {
+
+class MipsLinkingContext LLVM_FINAL : public ELFLinkingContext {
+public:
+  MipsLinkingContext(llvm::Triple triple);
+
+  /// \brief Number of local GOT entries.
+  std::size_t getLocalGOTCount() const;
+
+  /// \brief Number of global GOT entries.
+  std::size_t getGlobalGOTCount() const;
+
+  /// \brief Compare two atoms accordingly theirs positions in the GOT.
+  bool compareGOT(const Atom *a, const Atom *b) 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);
+
+private:
+  MipsGOT _got;
+};
+
+} // 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 "MipsGOT.h"
+#include "MipsLinkingContext.h"
+#include "MipsTargetHandler.h"
+
+#include "llvm/ADT/StringSwitch.h"
+
+using namespace lld;
+using namespace lld::elf;
+
+namespace {
+
+class MipsGOTPass : public Pass {
+public:
+  MipsGOTPass(MipsGOT &got) : _got(got) {}
+
+private:
+  /// \brief GOT handler.
+  MipsGOT &_got;
+
+  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);
+
+    _got.addAtoms(*mf);
+  }
+
+  /// \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;
+    }
+  }
+
+  error_code handleGOT(const Reference &ref) {
+    const_cast<Reference &>(ref).setTarget(_got.getEntry(ref.target()));
+    return error_code::success();
+  }
+};
+
+} // end anon namespace
+
+MipsLinkingContext::MipsLinkingContext(llvm::Triple triple)
+    : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
+                                    new MipsTargetHandler(*this))),
+      _got(*this)
+{}
+
+std::size_t MipsLinkingContext::getLocalGOTCount() const {
+  return _got.getLocalCount();
+}
+
+std::size_t MipsLinkingContext::getGlobalGOTCount() const {
+  return _got.getGlobalCount();
+}
+
+bool MipsLinkingContext::compareGOT(const Atom *a, const Atom *b) const {
+  return _got.compare(a, b);
+}
+
+bool MipsLinkingContext::isLittleEndian() const {
+  return MipsELFType::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) {
+  if (isDynamic())
+    pm.add(std::unique_ptr<Pass>(new MipsGOTPass(_got)));
+
+  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 "MipsELFTypes.h"
+
+namespace lld {
+namespace elf {
+
+class MipsLinkingContext;
+class MipsTargetHandler;
+
+class MipsTargetRelocationHandler LLVM_FINAL :
+    public TargetRelocationHandler<MipsELFType> {
+public:
+  MipsTargetRelocationHandler(const MipsLinkingContext &context,
+                              const MipsTargetHandler &tH);
+
+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;
+
+private:
+  virtual error_code applyRelocation(ELFWriter &,
+                                     llvm::FileOutputBuffer &,
+                                     const lld::AtomLayout &,
+                                     const Reference &) 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 {
+
+#define APPLY_RELOC(result)                                                  \
+  *reinterpret_cast<llvm::support::ulittle32_t *>(location) =                \
+      result |                                                               \
+      (uint32_t) * reinterpret_cast<llvm::support::ulittle32_t *>(location);
+
+// V - verify
+// T - truncate
+// AHL is (AHI << 16) + (short)ALO
+
+/// \brief R_MIPS_32
+/// local/external: T-word32 S + A
+void reloc32(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
+  uint32_t result = (uint32_t)(S + A);
+  APPLY_RELOC(result);
+}
+
+/// \brief R_MIPS_HI16
+/// local/external: T-hi16 ((AHL + S) - (short)(AHL + S)) >> 16
+/// _gp_disp      : V-hi16 ((AHL + GP - P) - (short)(AHL + GP - P)) >> 16
+void relocHi16(uint8_t *location, uint64_t P, uint64_t S, int64_t A,
+               uint64_t GOT, bool isGPDisp) {
+  int32_t AHL = A;
+
+  int32_t result = 0;
+  if (isGPDisp)
+    result = ((AHL + GOT - P) - (int16_t)(AHL + GOT - P)) >> 16;
+  else
+    result = ((AHL + S) - (int16_t)(AHL + S)) >> 16;
+
+  result = lld::scatterBits<uint32_t>(result, 0xffff);
+  APPLY_RELOC(result);
+}
+
+/// \brief R_MIPS_LO16
+/// local/external: T-lo16 AHL + S
+/// _gp_disp      : V-lo16 AHL + GP - P + 4
+void relocLo16(uint8_t *location, uint64_t P, uint64_t S, int64_t A,
+               uint64_t GOT, bool isGPDisp) {
+  int32_t AHL = A & 0xffff;
+
+  int32_t result = 0;
+  if (isGPDisp)
+    result = AHL + GOT - P + 4;
+  else
+    result = AHL + S;
+
+  result = lld::scatterBits<uint32_t>(result, 0xffff);
+  APPLY_RELOC(result);
+}
+
+/// \brief R_MIPS_GOT16
+/// local   : V-rel16 G (calculate AHL and put high 16 bit to GOT)
+/// external: V-rel16 G
+void relocGOT16(uint8_t *location, uint64_t P, uint64_t S, int64_t A,
+                uint64_t GOT) {
+  int32_t result = (int32_t)(S - GOT);
+
+  result = lld::scatterBits<uint32_t>(result, 0xffff);
+  APPLY_RELOC(result);
+}
+
+/// \brief R_MIPS_CALL16
+/// external: V-rel16 G
+void relocCall16(uint8_t *location, uint64_t P, uint64_t S, int64_t A,
+                 uint64_t GOT) {
+  int32_t result = (int32_t)(S - GOT);
+  result = lld::scatterBits<uint32_t>(result, 0xffff);
+  APPLY_RELOC(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 addend = ((ri->addend() & 0xffff) << 16) + (int16_t)loAddend;
+
+    switch (ri->kind()) {
+    case R_MIPS_HI16:
+      relocHi16(location, relocVAddress, targetVAddress, addend,
+                _targetHandler.getGPDispSymAddr(),
+                ri->target()->name() == "_gp_disp");
+      break;
+    case R_MIPS_GOT16:
+      relocGOT16(location, relocVAddress, targetVAddress, addend,
+                 _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, 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() << ")";
+    s.flush();
+    llvm_unreachable(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) {
+    this->_flags |= SHF_MIPS_GPREL;
+    this->_align2 = 16;
+  }
+};
+
+} // 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 "MipsRelocationHandler.h"
+#include "MipsSectionChunks.h"
+#include "MipsELFTypes.h"
+#include "TargetLayout.h"
+
+namespace lld {
+namespace elf {
+
+class MipsLinkingContext;
+
+/// \brief TargetLayout for Mips
+template <class MipsELFType>
+class MipsTargetLayout LLVM_FINAL : public TargetLayout<MipsELFType> {
+public:
+  MipsTargetLayout(const MipsLinkingContext &hti)
+      : TargetLayout<MipsELFType>(hti),
+        _gotSection(new (_alloc) MipsGOTSection<MipsELFType>(hti))
+  {}
+
+private:
+  llvm::BumpPtrAllocator _alloc;
+  MipsGOTSection<MipsELFType> *_gotSection;
+
+  virtual AtomSection<MipsELFType> *
+  createSection(StringRef name, int32_t type,
+                DefinedAtom::ContentPermissions permissions,
+                Layout::SectionOrder order) {
+    if (type == DefinedAtom::typeGOT)
+      return _gotSection;
+    return DefaultLayout<MipsELFType>::createSection(name, type, permissions,
+                                                     order);
+  }
+};
+
+/// \brief TargetHandler for Mips
+class MipsTargetHandler LLVM_FINAL : public DefaultTargetHandler<MipsELFType> {
+public:
+  MipsTargetHandler(MipsLinkingContext &targetInfo);
+
+  uint64_t getGPDispSymAddr() const;
+
+private:
+  virtual MipsTargetLayout<MipsELFType> &targetLayout();
+  virtual const MipsTargetRelocationHandler &getRelocationHandler() const;
+  virtual LLD_UNIQUE_BUMP_PTR(DynamicTable<MipsELFType>)
+    createDynamicTable(llvm::BumpPtrAllocator &alloc,
+                       StringRef name, int32_t order);
+  virtual LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<MipsELFType>)
+    createDynamicSymbolTable(llvm::BumpPtrAllocator &alloc,
+                             StringRef name, int32_t order);
+  virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &result);
+  virtual void finalizeSymbolValues();
+
+private:
+  MipsTargetLayout<MipsELFType> _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<MipsELFType> {
+public:
+  MipsDynamicSymbolTable(const ELFLinkingContext &context, StringRef str,
+                         int32_t order)
+      : DynamicSymbolTable<MipsELFType>(context, str, order)
+  {}
+
+private:
+  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();
+
+      const MipsLinkingContext &ctx =
+          static_cast<const MipsLinkingContext &>(_context);
+      return ctx.compareGOT(A._atom, B._atom);
+    });
+  }
+};
+
+class MipsDynamicTable : public DynamicTable<MipsELFType> {
+public:
+  MipsDynamicTable(const ELFLinkingContext &context, StringRef str,
+                   int32_t order)
+      : DynamicTable<MipsELFType>(context, str, order) {}
+
+private:
+  std::size_t _dt_symtabno;
+  std::size_t _dt_localgot;
+  std::size_t _dt_gotsym;
+  std::size_t _dt_pltgot;
+
+  virtual void createDefaultEntries() {
+    DynamicTable<MipsELFType>::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<MipsELFType>::updateDynamicTable();
+
+    const MipsLinkingContext &ctx =
+        static_cast<const MipsLinkingContext &>(_context);
+
+    auto &layout = _context.getTargetHandler<MipsELFType>().targetLayout();
+
+    getEntry(_dt_symtabno).d_un.d_val = getSymbolTable()->size();
+    getEntry(_dt_gotsym).d_un.d_val =
+        getSymbolTable()->size() - ctx.getGlobalGOTCount();
+    getEntry(_dt_localgot).d_un.d_val = ctx.getLocalGOTCount();
+    getEntry(_dt_pltgot).d_un.d_ptr =
+        layout.findOutputSection(".got")->virtualAddr();
+  }
+};
+
+}
+
+MipsTargetHandler::MipsTargetHandler(MipsLinkingContext &context)
+  : DefaultTargetHandler(context),
+    _targetLayout(context),
+    _relocationHandler(context, *this)
+{}
+
+uint64_t MipsTargetHandler::getGPDispSymAddr() const {
+  return _gpDispSymAtom ? _gpDispSymAtom->_virtualAddr : 0;
+}
+
+MipsTargetLayout<MipsELFType> &MipsTargetHandler::targetLayout() {
+  return _targetLayout;
+}
+
+const MipsTargetRelocationHandler &
+MipsTargetHandler::getRelocationHandler() const {
+  return _relocationHandler;
+}
+
+LLD_UNIQUE_BUMP_PTR(DynamicTable<MipsELFType>)
+MipsTargetHandler::createDynamicTable(llvm::BumpPtrAllocator &alloc,
+                                      StringRef name, int32_t order) {
+  return LLD_UNIQUE_BUMP_PTR(DynamicTable<MipsELFType>)(
+      new (alloc) MipsDynamicTable(_context, name, order));
+}
+
+LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<MipsELFType>)
+MipsTargetHandler::createDynamicSymbolTable(llvm::BumpPtrAllocator &alloc,
+                                            StringRef name, int32_t order) {
+  return LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<MipsELFType>)(
+      new (alloc) MipsDynamicSymbolTable(_context, name, order));
+}
+
+bool MipsTargetHandler::createImplicitFiles(
+    std::vector<std::unique_ptr<File>> &result) {
+  typedef CRuntimeFile<MipsELFType> 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<MipsELFType>::finalizeSymbolValues();
+
+  if (_context.isDynamic()) {
+    auto gotSection = _targetLayout.findOutputSection(".got");
+
+    auto gotAtomIter = _targetLayout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
+    _gotSymAtom = (*gotAtomIter);
+    _gotSymAtom->_virtualAddr = gotSection ? gotSection->virtualAddr() : 0;
+
+    auto gpDispAtomIter = _targetLayout.findAbsoluteAtom("_gp_disp");
+    _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(_alloc, ".dynamic",
+                                          DefaultLayout<ELFT>::ORDER_DYNAMIC));
     _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(
+        _alloc, ".dynsym", DefaultLayout<ELFT>::ORDER_DYNAMIC_SYMBOLS));
     _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> {
+protected:
   typedef typename llvm::object::ELFDataTypeTypedefHelper<ELFT>::Elf_Addr
       Elf_Addr;
   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);
+  SymbolTable(const ELFLinkingContext &context, StringRef 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)
protected:
   llvm::BumpPtrAllocator _symbolAllocate;
   StringTable<ELFT> *_stringSection;
   std::vector<SymbolEntry> _symbolTable;
 };
 
 /// ELF Symbol Table
 template <class ELFT>
 SymbolTable<ELFT>::SymbolTable(const ELFLinkingContext &context,
-                               const char *str, int32_t order)
+                               StringRef str, int32_t order)
     : Section<ELFT>(context, str) {
   this->setOrder(order);
   Elf_Sym symbol;
   std::memset(&symbol, 0, sizeof(Elf_Sym));
   _symbolTable.push_back(SymbolEntry(nullptr, symbol, nullptr));
   this->_entSize = sizeof(Elf_Sym);
   this->_fsize = sizeof(Elf_Sym);
   this->_align2 = sizeof(Elf_Addr);
for (const auto &sti : _symbolTable) {
     dest += sizeof(Elf_Sym);
   }
 }
 
 template <class ELFT> class HashSection;
 
 template <class ELFT> class DynamicSymbolTable : public SymbolTable<ELFT> {
 public:
-  DynamicSymbolTable(const ELFLinkingContext &context, const char *str,
+  DynamicSymbolTable(const ELFLinkingContext &context, StringRef str,
                      int32_t order)
       : SymbolTable<ELFT>(context, str, order), _hashTable(nullptr) {
     this->_type = SHT_DYNSYM;
     this->_flags = SHF_ALLOC;
     this->_msize = this->_fsize;
   }
 
   // Set the dynamic hash table for symbols to be added into

 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> {
+protected:
   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);
public:
   /// \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;
   }
 
+  /// \returns an entry by the index
+  Elf_Dyn &getEntry(std::size_t entry) {
+    return _entries[entry];
+  }
+
   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");

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(llvm::BumpPtrAllocator &alloc,
+                       StringRef name, int32_t order) = 0;
+
+  /// \brief create dynamic symbol table
+  virtual LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)
+      createDynamicSymbolTable(llvm::BumpPtrAllocator &alloc,
+                               StringRef name, int32_t order) = 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

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

 #ifndef LLD_READER_WRITER_ELF_X86_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_X86_TARGET_HANDLER_H
 
 #include "DefaultTargetHandler.h"
 #include "TargetLayout.h"
 
 namespace lld {
 namespace elf {
-typedef llvm::object::ELFType<llvm::support::little, 2, false> X86ELFType;
+typedef llvm::object::ELFType<llvm::support::little, 4, false> X86ELFType;
 class X86LinkingContext;
 
 class X86TargetRelocationHandler LLVM_FINAL
     : public TargetRelocationHandler<X86ELFType> {
 public:
   X86TargetRelocationHandler(const X86LinkingContext &context)
       : _context(context) {}
 

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 foo(void)
+{
+  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               0x144
+CHECK:   0x00000006 SYMTAB               0x104
+CHECK:   0x0000000A STRSZ                13 (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        4
+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@ (1)
+CHECK-DYN:     Value: 0x160
+CHECK-DYN:     Size: 128
+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@ (5)
+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@ (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: ]
+
+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:  - name:            '__got_$.str'
+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:  - name:            '__got_$.str1'
+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:  - name:            __got_xyz
+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:  - name:            __got_abc
+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-

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: 0x160
+CHECK:  ProgramHeaderOffset: 0x34
+CHECK:  SectionHeaderOffset: 0x2200
+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          00000018 0000000000001000 DATA 
+
+CHECK: SYMBOL TABLE:
+CHECK: 00001000 g       *ABS*  00000000 _GLOBAL_OFFSET_TABLE_
+CHECK: 00008ff0 g       *ABS*  00000000 _gp_disp

test/elf/Mips/dynlib-text-sec.test

+# Check .text section content
+RUN: lld -flavor gnu -target mipsel -shared --noinhibit-exec \
+RUN:     -o %t %p/Inputs/dynobj.o
+RUN: llvm-objdump -s %t | FileCheck %s
+
+CHECK: Contents of section .text:
+CHECK-NEXT: 0160 0100023c 908e4224 e0ffbd27 1c00bfaf  ...<..B$...'....
+CHECK-NEXT: 0170 1800beaf 21f0a003 21105900 1880598c  ....!...!.Y...Y.
+CHECK-NEXT: 0180 e0012427 2080598c 21e04000 1400c2af  ..$' .Y.!.@.....
+CHECK-NEXT: 0190 09f82003 00000000 1400c48f 1c80998c  .. .............
+CHECK-NEXT: 01a0 e5012427 1400d98f 2480398f 1400dc8f  ..$'....$.9.....
+CHECK-NEXT: 01b0 1000c2af 09f82003 00000000 1000c48f  ...... .........
+CHECK-NEXT: 01c0 21108200 21e8c003 1800be8f 1c00bf8f  !...!...........
+CHECK-NEXT: 01d0 2000bd27 0800e003 00000000 00000000   ..'............