diff --git a/include/mcld/Fragment/Stub.h b/include/mcld/Fragment/Stub.h
index 94f58e9..3ef72ec 100644
--- a/include/mcld/Fragment/Stub.h
+++ b/include/mcld/Fragment/Stub.h
@@ -20,6 +20,8 @@
 
 namespace mcld {
 
+class BranchIsland;
+class IRBuilder;
 class Relocation;
 class ResolveInfo;
 
@@ -63,9 +65,15 @@
 
   /// isMyDuty - return true when the pReloc is problematic and the stub is able
   /// to fix it!
-  virtual bool isMyDuty(const class Relocation& pReloc,
+  virtual bool isMyDuty(const Relocation& pReloc,
                         uint64_t pSource,
-                        uint64_t pTargetSymValue) const = 0;
+                        uint64_t pTargetSymValue) const {
+    return false;
+  }
+
+  virtual bool isMyDuty(const FragmentRef& pFragRef) const {
+    return false;
+  }
 
   /// name - name of this stub
   virtual const std::string& name() const = 0;
@@ -96,6 +104,16 @@
 
   const_fixup_iterator fixup_end() const { return m_FixupList.end(); }
 
+  size_t fixup_size() const { return m_FixupList.size(); }
+
+  virtual void applyFixup(Relocation& pSrcReloc,
+                          IRBuilder& pBuilder,
+                          BranchIsland& pIsland);
+
+  virtual void applyFixup(FragmentRef& pSrcFragRef,
+                          IRBuilder& pBuilder,
+                          BranchIsland& pIsland);
+
   /// ----- modifiers ----- ///
   void setSymInfo(ResolveInfo* pSymInfo);
 
@@ -113,6 +131,9 @@
   /// addFixup - add a fixup from a existing fixup of the prototype
   void addFixup(const Fixup& pFixup);
 
+  const FixupListType& getFixupList() const { return m_FixupList; }
+  FixupListType&       getFixupList()       { return m_FixupList; }
+
  private:
   /// doClone - when adding a backend stub, we should implement this function
   virtual Stub* doClone() = 0;
diff --git a/include/mcld/GeneralOptions.h b/include/mcld/GeneralOptions.h
index 787c5eb..5b9c92b 100644
--- a/include/mcld/GeneralOptions.h
+++ b/include/mcld/GeneralOptions.h
@@ -251,11 +251,6 @@
 
   bool genUnwindInfo() const { return m_bGenUnwindInfo; }
 
-  // -G, max GP size option
-  void setGPSize(int gpsize) { m_GPSize = gpsize; }
-
-  int getGPSize() const { return m_GPSize; }
-
   HashStyle getHashStyle() const { return m_HashStyle; }
 
   bool hasGNUHash() const {
@@ -388,7 +383,6 @@
   bool m_bPrintICFSections : 1;   // --print-icf-sections
   ICF m_ICF;
   size_t m_ICFIterations;
-  uint32_t m_GPSize;  // -G, --gpsize
   StripSymbolMode m_StripSymbols;
   RpathList m_RpathList;
   ScriptList m_ScriptList;
diff --git a/include/mcld/IRBuilder.h b/include/mcld/IRBuilder.h
index b68b8fa..e613dac 100644
--- a/include/mcld/IRBuilder.h
+++ b/include/mcld/IRBuilder.h
@@ -353,6 +353,9 @@
   /// @return Total size of the inserted fragments.
   static uint64_t AppendEhFrame(EhFrame::CIE& pCIE, EhFrame& pEhFrame);
 
+  /// CreateLocalSymbol - Create a local symbol at the given FragmentRef.
+  ResolveInfo* CreateLocalSymbol(FragmentRef& pFragRef);
+
   /// AddSymbol - To add a symbol to the input file.
   /// This function create a new symbol and insert it into the input file. If
   /// mcld::Module has another symbol with the same name, then this function
diff --git a/include/mcld/LD/BranchIsland.h b/include/mcld/LD/BranchIsland.h
index c57e5fb..1e7ccda 100644
--- a/include/mcld/LD/BranchIsland.h
+++ b/include/mcld/LD/BranchIsland.h
@@ -74,6 +74,8 @@
   const_reloc_iterator reloc_end() const { return m_Relocations.end(); }
 
   /// observers
+  SectionData* getParent() const { return m_Entry.getParent(); }
+
   uint64_t offset() const;
 
   size_t size() const;
@@ -91,6 +93,8 @@
   /// addStub - add a stub into the island
   bool addStub(const Stub* pPrototype, const Relocation& pReloc, Stub& pStub);
 
+  void addStub(Stub& pStub);
+
   /// addRelocation - add a relocation into island
   bool addRelocation(Relocation& pReloc);
 
@@ -159,7 +163,7 @@
   Fragment& m_Entry;  // entry fragment of the island
   Fragment* m_pExit;  // exit fragment of the island
   Fragment* m_pRear;  // rear fragment of the island
-  size_t m_MaxSize;
+  const size_t m_MaxSize;
   std::string m_Name;
   StubMapType m_StubMap;
   /// m_Relocations - list of relocations created for stubs in this island
diff --git a/include/mcld/LD/BranchIslandFactory.h b/include/mcld/LD/BranchIslandFactory.h
index 575d40f..545173d 100644
--- a/include/mcld/LD/BranchIslandFactory.h
+++ b/include/mcld/LD/BranchIslandFactory.h
@@ -28,11 +28,10 @@
   /// ctor
   /// @param pMaxFwdBranchRange - the max forward branch range of the target
   /// @param pMaxBwdBranchRange - the max backward branch range of the target
-  /// @param pMaxIslandSize - a predifned value (64KB here) to decide the max
-  ///                         size of the island
+  /// @param pMaxIslandSize - the group size to place stubs between sections
   BranchIslandFactory(int64_t pMaxFwdBranchRange,
                       int64_t pMaxBwdBranchRange,
-                      size_t pMaxIslandSize = 65536U);
+                      size_t pMaxIslandSize);
 
   ~BranchIslandFactory();
 
diff --git a/include/mcld/LD/DiagCommonKinds.inc b/include/mcld/LD/DiagCommonKinds.inc
index 8340cd8..ac44022 100644
--- a/include/mcld/LD/DiagCommonKinds.inc
+++ b/include/mcld/LD/DiagCommonKinds.inc
@@ -181,8 +181,8 @@
      "unable to write output file %0")
 DIAG(warn_unsupported_option,
      DiagnosticEngine::Warning,
-     "Option `%0' is not implemented yet!",
-     "Option `%0' is not implemented yet!")
+     "%0: unsupported option",
+     "%0: unsupported option")
 DIAG(warn_shared_textrel,
      DiagnosticEngine::Warning,
      "Add DT_TEXTREL in a shared object!",
@@ -223,7 +223,3 @@
      DiagnosticEngine::Fatal,
      "missing text section for '%0' in file '%1'",
      "missing text section for '%0' in file '%1'")
-DIAG(eh_missing_exidx_section,
-     DiagnosticEngine::Fatal,
-     "missing .ARM.exidx section for '%0' in file '%1'",
-     "missing .ARM.exidx section for '%0' in file '%1'")
diff --git a/include/mcld/LD/DiagLayouts.inc b/include/mcld/LD/DiagLayouts.inc
index c41b775..e0e6d09 100644
--- a/include/mcld/LD/DiagLayouts.inc
+++ b/include/mcld/LD/DiagLayouts.inc
@@ -32,3 +32,9 @@
      DiagnosticEngine::Debug,
      "ICF folding section `%0' of `%1' into `%2' of `%3'",
      "ICF folding section `%0' of `%1' into `%2' of `%3'")
+DIAG(err_no_space_to_place_stubs,
+     DiagnosticEngine::Error,
+     "There is no space left to place stubs. Current stub group size: %0\n"
+     "Use --stub-group-size option to increase the group size.",
+     "There is no space left to place stubs. Current stub group size: %0\n"
+     "Use --stub-group-size option to increase the group size.")
diff --git a/include/mcld/LD/DiagMips.inc b/include/mcld/LD/DiagMips.inc
new file mode 100644
index 0000000..48c0169
--- /dev/null
+++ b/include/mcld/LD/DiagMips.inc
@@ -0,0 +1,53 @@
+// Mips specific errors and warnings on object file incompatibilities
+DIAG(error_Mips_incompatible_class,
+     DiagnosticEngine::Fatal,
+     "target '%0' is incompatible with '%1' in %2",
+     "target '%0' is incompatible with '%1' in %2")
+DIAG(error_Mips_inconsistent_arch,
+     DiagnosticEngine::Error,
+     "target arch '%0' is inconsist with the '%1' in %2",
+     "target arch '%0' is inconsist with the '%1' in %2")
+DIAG(error_Mips_abiflags_invalid_size,
+     DiagnosticEngine::Error,
+     "invalid size of .MIPS.abiflags section in %0",
+     "invalid size of .MIPS.abiflags section in %0")
+DIAG(error_Mips_abiflags_invalid_version,
+     DiagnosticEngine::Error,
+     "unexpected .MIPS.abiflags section version number '%0' in %1",
+     "unexpected .MIPS.abiflags section version number '%0' in %1")
+DIAG(error_Mips_inconsistent_abi,
+     DiagnosticEngine::Error,
+     "target ABI is incompatible with ABI in %0",
+     "target ABI is incompatible with ABI in %0")
+DIAG(error_Mips_inconsistent_mnan,
+     DiagnosticEngine::Error,
+     "target -mnan=%0 flag is incompatible with -mnan=%1 in %2",
+     "target -mnan=%0 flag is incompatible with -mnan=%1 in %2")
+DIAG(error_Mips_inconsistent_fp64,
+     DiagnosticEngine::Error,
+     "target -mfp flag is incompatible with -mfp in %0",
+     "target -mfp flag is incompatible with -mfp in %0")
+DIAG(error_Mips_m16_unsupported,
+     DiagnosticEngine::Error,
+     "MIPS16 extension is unsupported: %0",
+     "MIPS16 extension is unsupported: %0")
+DIAG(warn_Mips_abicalls_linking,
+     DiagnosticEngine::Warning,
+     "conflicting linking abicalls and non-abicalls files on %0.",
+     "conflicting linking abicalls and non-abicalls files on %0.")
+DIAG(warn_Mips_fp_abi_incompatible,
+     DiagnosticEngine::Warning,
+     "FP ABI %0 is incompatible with %1 used by %2",
+     "FP ABI %0 is incompatible with %1 used by %2")
+DIAG(warn_Mips_isa_incompatible,
+     DiagnosticEngine::Warning,
+     "inconsistent ISA between .MIPS.abiflags and ELF header e_flags field: %0",
+     "inconsistent ISA between .MIPS.abiflags and ELF header e_flags field: %0")
+DIAG(warn_Mips_isa_ext_incompatible,
+     DiagnosticEngine::Warning,
+     "inconsistent ISA extensions between .MIPS.abiflags and ELF header e_flags field: %0",
+     "inconsistent ISA extensions between .MIPS.abiflags and ELF header e_flags field: %0")
+DIAG(warn_Mips_ases_incompatible,
+     DiagnosticEngine::Warning,
+     "inconsistent ASEs between .MIPS.abiflags and ELF header e_flags field: %0",
+     "inconsistent ASEs between .MIPS.abiflags and ELF header e_flags field: %0")
diff --git a/include/mcld/LD/DiagnosticInfos.h b/include/mcld/LD/DiagnosticInfos.h
index 804394e..a82fda9 100644
--- a/include/mcld/LD/DiagnosticInfos.h
+++ b/include/mcld/LD/DiagnosticInfos.h
@@ -24,6 +24,7 @@
 #include "mcld/LD/DiagLayouts.inc"
 #include "mcld/LD/DiagGOTPLT.inc"
 #include "mcld/LD/DiagLDScript.inc"
+#include "mcld/LD/DiagMips.inc"
 #undef DIAG
   NUM_OF_BUILDIN_DIAGNOSTIC_INFO
 };
diff --git a/include/mcld/LD/ELFSegmentFactory.h b/include/mcld/LD/ELFSegmentFactory.h
index 12a5831..05c6747 100644
--- a/include/mcld/LD/ELFSegmentFactory.h
+++ b/include/mcld/LD/ELFSegmentFactory.h
@@ -57,6 +57,10 @@
   /// @param pType - p_type in ELF program header
   ELFSegment* produce(uint32_t pType, uint32_t pFlag = llvm::ELF::PF_R);
 
+  ELFSegment* insert(iterator pPosition,
+                     uint32_t pType,
+                     uint32_t pFlag = llvm::ELF::PF_R);
+
   void erase(iterator pSegment);
 
  private:
diff --git a/include/mcld/LD/StubFactory.h b/include/mcld/LD/StubFactory.h
index 2a093d0..b3adf98 100644
--- a/include/mcld/LD/StubFactory.h
+++ b/include/mcld/LD/StubFactory.h
@@ -17,6 +17,7 @@
 
 class BranchIslandFactory;
 class IRBuilder;
+class FragmentRef;
 class Relocation;
 class Stub;
 
@@ -37,12 +38,18 @@
                IRBuilder& pBuilder,
                BranchIslandFactory& pBRIslandFactory);
 
+  Stub* create(FragmentRef& pFragRef,
+               IRBuilder& pBuilder,
+               BranchIslandFactory& pBRIslandFactory);
+
  private:
   /// findPrototype - find if there is a registered stub prototype for the given
   ///                 relocation
   Stub* findPrototype(const Relocation& pReloc,
                       const uint64_t pSource,
-                      uint64_t pTargetSymValue);
+                      uint64_t pTargetSymValue) const;
+
+  Stub* findPrototype(const FragmentRef& pFragRef) const;
 
  private:
   typedef std::vector<Stub*> StubPoolType;
diff --git a/include/mcld/Script/ScriptScanner.h b/include/mcld/Script/ScriptScanner.h
index 4a572a1..da54750 100644
--- a/include/mcld/Script/ScriptScanner.h
+++ b/include/mcld/Script/ScriptScanner.h
@@ -10,7 +10,11 @@
 #define MCLD_SCRIPT_SCRIPTSCANNER_H_
 
 #ifndef __FLEX_LEXER_H
-#include "FlexLexer.h"
+#ifdef ANDROID
+#include "mcld/Script/FlexLexer.h"
+#else
+#include <FlexLexer.h>
+#endif
 #endif
 
 #ifndef YY_DECL
diff --git a/include/mcld/Target/GNUInfo.h b/include/mcld/Target/GNUInfo.h
index 2a55688..d09e5d9 100644
--- a/include/mcld/Target/GNUInfo.h
+++ b/include/mcld/Target/GNUInfo.h
@@ -35,8 +35,7 @@
   virtual uint8_t ABIVersion() const { return 0x0; }
 
   /// defaultTextSegmentAddr - target should specify its own default start
-  /// address
-  /// of the text segment. esp. for exec.
+  /// address of the text segment. esp. for exec.
   virtual uint64_t defaultTextSegmentAddr() const { return 0x0; }
 
   /// flags - the value of ElfXX_Ehdr::e_flags
@@ -47,7 +46,6 @@
 
   /// dyld - the name of the default dynamic linker
   /// target may override this function if needed.
-  /// @ref gnu ld, bfd/elf32-i386.c:521
   virtual const char* dyld() const { return "/usr/lib/libc.so.1"; }
 
   /// isDefaultExecStack - target should specify whether the stack is default
@@ -62,6 +60,9 @@
   /// here. If target favors the different size, please override this function
   virtual uint64_t abiPageSize() const { return 0x1000; }
 
+  /// stubGroupSize - the default group size to place stubs between sections.
+  virtual unsigned stubGroupSize() const { return 0x10000; }
+
  protected:
   const llvm::Triple& m_Triple;
 };
diff --git a/include/mcld/Target/GNULDBackend.h b/include/mcld/Target/GNULDBackend.h
index 212d081..a396084 100644
--- a/include/mcld/Target/GNULDBackend.h
+++ b/include/mcld/Target/GNULDBackend.h
@@ -189,6 +189,9 @@
   /// Different concrete target backend may overlap this function.
   virtual bool allocateCommonSymbols(Module& pModule);
 
+  /// mergeFlags - update set of ELF header flags
+  virtual void mergeFlags(Input& pInput, const char* ELF_hdr) {}
+
   /// updateSectionFlags - update pTo's flags when merging pFrom
   /// update the output section flags based on input section flags.
   virtual bool updateSectionFlags(LDSection& pTo, const LDSection& pFrom);
@@ -307,11 +310,14 @@
 
   /// maxFwdBranchOffset - return the max forward branch offset of the backend.
   /// Target can override this function if needed.
-  virtual int64_t maxFwdBranchOffset() { return INT64_MAX; }
+  virtual int64_t maxFwdBranchOffset() const { return INT64_MAX; }
 
   /// maxBwdBranchOffset - return the max backward branch offset of the backend.
   /// Target can override this function if needed.
-  virtual int64_t maxBwdBranchOffset() { return 0; }
+  virtual int64_t maxBwdBranchOffset() const { return 0; }
+
+  /// stubGroupSize - return the group size to place stubs between sections.
+  virtual unsigned stubGroupSize() const;
 
   /// checkAndSetHasTextRel - check pSection flag to set HasTextRel
   void checkAndSetHasTextRel(const LDSection& pSection);
diff --git a/include/mcld/TargetOptions.h b/include/mcld/TargetOptions.h
index 23a376b..2c7d973 100644
--- a/include/mcld/TargetOptions.h
+++ b/include/mcld/TargetOptions.h
@@ -58,12 +58,37 @@
   bool is32Bits() const { return (32 == m_BitClass); }
   bool is64Bits() const { return (64 == m_BitClass); }
 
+  // -G, max GP size option
+  void setGPSize(unsigned pGPSize) { m_GPSize = pGPSize; }
+
+  unsigned getGPSize() const { return m_GPSize; }
+
+  void setStubGroupSize(unsigned pSize) { m_StubGroupSize = pSize; }
+
+  unsigned getStubGroupSize() const { return m_StubGroupSize; }
+
+  void setFixCA53Erratum835769(bool pEnable = true) {
+    m_FixCA53Erratum835769 = pEnable;
+  }
+
+  bool fixCA53Erratum835769() const { return m_FixCA53Erratum835769; }
+
+  void setFixCA53Erratum843419(bool pEnable = true) {
+    m_FixCA53Erratum843419 = pEnable;
+  }
+
+  bool fixCA53Erratum843419() const { return m_FixCA53Erratum843419; }
+
  private:
   llvm::Triple m_Triple;
   std::string m_ArchName;
   std::string m_TargetCPU;
   Endian m_Endian;
   unsigned int m_BitClass;
+  unsigned m_GPSize;  // -G, --gpsize
+  unsigned m_StubGroupSize;
+  bool m_FixCA53Erratum835769 : 1;
+  bool m_FixCA53Erratum843419 : 1;
 };
 
 }  // namespace mcld
diff --git a/lib/Core/GeneralOptions.cpp b/lib/Core/GeneralOptions.cpp
index 1996acf..c7d0dde 100644
--- a/lib/Core/GeneralOptions.cpp
+++ b/lib/Core/GeneralOptions.cpp
@@ -61,7 +61,6 @@
       m_bPrintICFSections(false),
       m_ICF(ICF::None),
       m_ICFIterations(2),
-      m_GPSize(8),
       m_StripSymbols(StripSymbolMode::KeepAllSymbols),
       m_HashStyle(HashStyle::SystemV) {
 }
diff --git a/lib/Core/IRBuilder.cpp b/lib/Core/IRBuilder.cpp
index 252fc43..4c6eab8 100644
--- a/lib/Core/IRBuilder.cpp
+++ b/lib/Core/IRBuilder.cpp
@@ -601,6 +601,36 @@
   return relocation;
 }
 
+ResolveInfo* IRBuilder::CreateLocalSymbol(FragmentRef& pFragRef) {
+  // Create and add symbol to the name pool.
+  ResolveInfo* resolveInfo =
+      m_Module.getNamePool().createSymbol(/* pName */"",
+                                          /* pIsDyn */false,
+                                          ResolveInfo::Section,
+                                          ResolveInfo::Define,
+                                          ResolveInfo::Local,
+                                          /* pSize */0,
+                                          ResolveInfo::Hidden);
+  if (resolveInfo == nullptr) {
+    return nullptr;
+  }
+
+  // Create input symbol.
+  LDSymbol* inputSym = LDSymbol::Create(*resolveInfo);
+  if (inputSym == nullptr) {
+    return nullptr;
+  }
+
+  inputSym->setFragmentRef(FragmentRef::Create(*pFragRef.frag(),
+                                               pFragRef.offset()));
+  inputSym->setValue(/* pValue */0);
+
+  // The output symbol is simply an alias to the input symbol.
+  resolveInfo->setSymPtr(inputSym);
+
+  return resolveInfo;
+}
+
 /// AddSymbol - define an output symbol and override it immediately
 template <>
 LDSymbol* IRBuilder::AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
diff --git a/lib/Core/TargetOptions.cpp b/lib/Core/TargetOptions.cpp
index c7678ba..e830710 100644
--- a/lib/Core/TargetOptions.cpp
+++ b/lib/Core/TargetOptions.cpp
@@ -13,11 +13,21 @@
 //===----------------------------------------------------------------------===//
 // TargetOptions
 //===----------------------------------------------------------------------===//
-TargetOptions::TargetOptions() : m_Endian(Unknown), m_BitClass(0) {
+TargetOptions::TargetOptions()
+    : m_Endian(Unknown),
+      m_BitClass(0),
+      m_GPSize(8),
+      m_StubGroupSize(0),
+      m_FixCA53Erratum835769(false) {
 }
 
 TargetOptions::TargetOptions(const std::string& pTriple)
-    : m_Triple(pTriple), m_Endian(Unknown), m_BitClass(0) {
+    : m_Triple(pTriple),
+      m_Endian(Unknown),
+      m_BitClass(0),
+      m_GPSize(8),
+      m_StubGroupSize(0),
+      m_FixCA53Erratum835769(false) {
 }
 
 TargetOptions::~TargetOptions() {
diff --git a/lib/Fragment/Stub.cpp b/lib/Fragment/Stub.cpp
index b658ece..53fe776 100644
--- a/lib/Fragment/Stub.cpp
+++ b/lib/Fragment/Stub.cpp
@@ -8,6 +8,13 @@
 //===----------------------------------------------------------------------===//
 #include "mcld/Fragment/Stub.h"
 
+#include "mcld/IRBuilder.h"
+#include "mcld/Fragment/Relocation.h"
+#include "mcld/LD/BranchIsland.h"
+#include "mcld/LD/ResolveInfo.h"
+
+#include <cassert>
+
 namespace mcld {
 
 Stub::Stub() : Fragment(Fragment::Stub), m_pSymInfo(NULL) {
@@ -22,6 +29,49 @@
   m_pSymInfo = pSymInfo;
 }
 
+void Stub::applyFixup(Relocation& pSrcReloc,
+                      IRBuilder& pBuilder,
+                      BranchIsland& pIsland) {
+  // build a name for stub symbol
+  std::string sym_name("__");
+  sym_name.append(pSrcReloc.symInfo()->name())
+          .append("_")
+          .append(name())
+          .append("@")
+          .append(pIsland.name());
+
+  // create LDSymbol for the stub
+  LDSymbol* symbol =
+      pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
+          sym_name,
+          ResolveInfo::Function,
+          ResolveInfo::Define,
+          ResolveInfo::Local,
+          size(),
+          initSymValue(),
+          FragmentRef::Create(*this, initSymValue()),
+          ResolveInfo::Default);
+  setSymInfo(symbol->resolveInfo());
+
+  // add relocations of this stub (i.e., set the branch target of the stub)
+  for (fixup_iterator it = fixup_begin(), ie = fixup_end(); it != ie; ++it) {
+    Relocation* reloc =
+        Relocation::Create((*it)->type(),
+                           *(FragmentRef::Create(*this, (*it)->offset())),
+                           (*it)->addend());
+    reloc->setSymInfo(pSrcReloc.symInfo());
+    pIsland.addRelocation(*reloc);
+  }
+}
+
+void Stub::applyFixup(FragmentRef& pSrcFragRef,
+                      IRBuilder& pBuilder,
+                      BranchIsland& pIsland) {
+  // If applying fixups is based on the source FragmentRef, each target stub
+  // probably should override this function.
+  assert(0 && "target stub should override this function");
+}
+
 void Stub::addFixup(DWord pOffset, SWord pAddend, Type pType) {
   assert(pOffset < size());
   m_FixupList.push_back(new Fixup(pOffset, pAddend, pType));
diff --git a/lib/LD/BranchIsland.cpp b/lib/LD/BranchIsland.cpp
index 0405263..e3237df 100644
--- a/lib/LD/BranchIsland.cpp
+++ b/lib/LD/BranchIsland.cpp
@@ -17,9 +17,9 @@
 
 namespace mcld {
 
-//==========================
+//============================================================================//
 // BranchIsland
-
+//============================================================================//
 BranchIsland::BranchIsland(Fragment& pEntryFrag, size_t pMaxSize, size_t pIndex)
     : m_Entry(pEntryFrag),
       m_pExit(pEntryFrag.getNextNode()),
@@ -123,6 +123,30 @@
   return !exist;
 }
 
+void BranchIsland::addStub(Stub& pStub) {
+  bool exist = false;
+  Key key(&pStub, pStub.symInfo()->outSymbol(), 0);
+  m_StubMap.insert(key, exist);
+
+  m_pRear = &pStub;
+  SectionData* sd = m_Entry.getParent();
+
+  // insert alignment fragment
+  // TODO: check if we can reduce this alignment fragment for some cases
+  AlignFragment* align_frag =
+      new AlignFragment(pStub.alignment(), 0x0, 1u, pStub.alignment() - 1);
+  align_frag->setParent(sd);
+  sd->getFragmentList().insert(end(), align_frag);
+  align_frag->setOffset(align_frag->getPrevNode()->getOffset() +
+                        align_frag->getPrevNode()->size());
+
+  // insert stub fragment
+  pStub.setParent(sd);
+  sd->getFragmentList().insert(end(), &pStub);
+  pStub.setOffset(pStub.getPrevNode()->getOffset() +
+                  pStub.getPrevNode()->size());
+}
+
 /// addRelocation - add a relocation into island
 bool BranchIsland::addRelocation(Relocation& pReloc) {
   m_Relocations.push_back(&pReloc);
diff --git a/lib/LD/BranchIslandFactory.cpp b/lib/LD/BranchIslandFactory.cpp
index cace800..bc9f603 100644
--- a/lib/LD/BranchIslandFactory.cpp
+++ b/lib/LD/BranchIslandFactory.cpp
@@ -38,25 +38,27 @@
 /// group - group fragments and create islands when needed
 /// @param pSectionData - the SectionData holds fragments need to be grouped
 void BranchIslandFactory::group(Module& pModule) {
-  /* FIXME: Currently only support relaxing .text section! */
-  LDSection* text = pModule.getSection(".text");
-  if (text != NULL && text->hasSectionData()) {
-    SectionData& sd = *text->getSectionData();
-    uint64_t group_end = m_MaxFwdBranchRange;
-    for (SectionData::iterator it = sd.begin(), ie = sd.end(); it != ie; ++it) {
-      if ((*it).getOffset() + (*it).size() > group_end) {
-        Fragment* frag = (*it).getPrevNode();
-        while (frag != NULL && frag->getKind() == Fragment::Alignment) {
-          frag = frag->getPrevNode();
-        }
-        if (frag != NULL) {
-          produce(*frag);
-          group_end = (*it).getOffset() + m_MaxFwdBranchRange;
+  for (Module::iterator sect = pModule.begin(), sectEnd = pModule.end();
+       sect != sectEnd; ++sect) {
+    if (((*sect)->kind() == LDFileFormat::TEXT) && (*sect)->hasSectionData()) {
+      SectionData& sd = *((*sect)->getSectionData());
+      uint64_t group_end = m_MaxFwdBranchRange;
+      for (SectionData::iterator it = sd.begin(), ie = sd.end(); it != ie;
+           ++it) {
+        if ((*it).getOffset() + (*it).size() > group_end) {
+          Fragment* frag = (*it).getPrevNode();
+          while (frag != NULL && frag->getKind() == Fragment::Alignment) {
+            frag = frag->getPrevNode();
+          }
+          if (frag != NULL) {
+            produce(*frag);
+            group_end = (*it).getOffset() + m_MaxFwdBranchRange;
+          }
         }
       }
+      if (getIslands(sd.back()).first == NULL)
+        produce(sd.back());
     }
-    if (getIslands(sd.back()).first == NULL)
-      produce(sd.back());
   }
 }
 
@@ -78,11 +80,15 @@
   BranchIsland* bwd = NULL;
   for (iterator it = begin(), ie = end(), prev = ie; it != ie;
        prev = it, ++it) {
+    if (pFragment.getParent() != (*it).getParent()) {
+      continue;
+    }
+
     if ((pFragment.getOffset() < (*it).offset()) &&
         ((pFragment.getOffset() + m_MaxFwdBranchRange) >= (*it).offset())) {
       fwd = &*it;
 
-      if (prev != ie) {
+      if ((prev != ie) && (pFragment.getParent() == (*prev).getParent())) {
         int64_t bwd_off = (int64_t)pFragment.getOffset() + m_MaxBwdBranchRange;
         if ((pFragment.getOffset() > (*prev).offset()) &&
             (bwd_off <= (int64_t)(*prev).offset())) {
diff --git a/lib/LD/DiagnosticInfos.cpp b/lib/LD/DiagnosticInfos.cpp
index 080c318..0ba2e9c 100644
--- a/lib/LD/DiagnosticInfos.cpp
+++ b/lib/LD/DiagnosticInfos.cpp
@@ -51,6 +51,7 @@
 #include "mcld/LD/DiagLayouts.inc"  // NOLINT [build/include] [4]
 #include "mcld/LD/DiagGOTPLT.inc"  // NOLINT [build/include] [4]
 #include "mcld/LD/DiagLDScript.inc"  // NOLINT [build/include] [4]
+#include "mcld/LD/DiagMips.inc"  // NOLINT [build/include] [4]
 #undef DIAG
     {0, DiagnosticEngine::None, 0, 0}};
 
@@ -69,6 +70,7 @@
 #include "mcld/LD/DiagLayouts.inc"  // NOLINT [build/include] [4]
 #include "mcld/LD/DiagGOTPLT.inc"  // NOLINT [build/include] [4]
 #include "mcld/LD/DiagLDScript.inc"  // NOLINT [build/include] [4]
+#include "mcld/LD/DiagMips.inc"  // NOLINT [build/include] [4]
 #undef DIAG
     {0, DiagnosticEngine::None, 0, 0}};
 
diff --git a/lib/LD/ELFObjectReader.cpp b/lib/LD/ELFObjectReader.cpp
index aeefd37..bcd031c 100644
--- a/lib/LD/ELFObjectReader.cpp
+++ b/lib/LD/ELFObjectReader.cpp
@@ -100,6 +100,7 @@
   llvm::StringRef region =
       pInput.memArea()->request(pInput.fileOffset(), hdr_size);
   const char* ELF_hdr = region.begin();
+  m_Backend.mergeFlags(pInput, ELF_hdr);
   bool result = m_pELFReader->readSectionHeaders(pInput, ELF_hdr);
   return result;
 }
diff --git a/lib/LD/ELFSegmentFactory.cpp b/lib/LD/ELFSegmentFactory.cpp
index de2d175..678bbfc 100644
--- a/lib/LD/ELFSegmentFactory.cpp
+++ b/lib/LD/ELFSegmentFactory.cpp
@@ -80,6 +80,12 @@
   return back();
 }
 
+ELFSegment* ELFSegmentFactory::insert(iterator pPosition,
+                                      uint32_t pType,
+                                      uint32_t pFlag) {
+  return *(m_Segments.insert(pPosition, ELFSegment::Create(pType, pFlag)));
+}
+
 void ELFSegmentFactory::erase(iterator pSegment) {
   m_Segments.erase(pSegment);
 }
diff --git a/lib/LD/EhFrameReader.cpp b/lib/LD/EhFrameReader.cpp
index 383c1ee..f26a5cd 100644
--- a/lib/LD/EhFrameReader.cpp
+++ b/lib/LD/EhFrameReader.cpp
@@ -197,10 +197,14 @@
     return false;
   }
   // skip the Return Address Register
-  if (cie_end - handler < 1) {
-    return false;
+  if (version == 1) {
+    if (cie_end - handler < 1)
+      return false;
+    ++handler;
+  } else {
+    if (!skip_LEB128(&handler, cie_end))
+      return false;
   }
-  ++handler;
 
   llvm::StringRef augment((const char*)aug_str_front);
 
diff --git a/lib/LD/IdenticalCodeFolding.cpp b/lib/LD/IdenticalCodeFolding.cpp
index 527dccb..5ba0fc1 100644
--- a/lib/LD/IdenticalCodeFolding.cpp
+++ b/lib/LD/IdenticalCodeFolding.cpp
@@ -232,22 +232,21 @@
 
   // Get the static content from relocs.
   if (reloc_sect != NULL && reloc_sect->hasRelocData()) {
-    RelocData::iterator rel, relEnd = reloc_sect->getRelocData()->end();
-    for (rel = reloc_sect->getRelocData()->begin(); rel != relEnd; ++rel) {
+    for (Relocation& rel : *reloc_sect->getRelocData()) {
       llvm::format_object<Relocation::Type,
                           Relocation::Address,
                           Relocation::Address,
                           Relocation::Address> rel_info("%x%llx%llx%llx",
-                                                        rel->type(),
-                                                        rel->symValue(),
-                                                        rel->addend(),
-                                                        rel->place());
+                                                        rel.type(),
+                                                        rel.symValue(),
+                                                        rel.addend(),
+                                                        rel.place());
       char rel_str[48];
       rel_info.print(rel_str, sizeof(rel_str));
       content.append(rel_str);
 
       // Handle the recursive call.
-      LDSymbol* sym = rel->symInfo()->outSymbol();
+      LDSymbol* sym = rel.symInfo()->outSymbol();
       if ((sym->type() == ResolveInfo::Function) && sym->hasFragRef()) {
         LDSection* def = &sym->fragRef()->frag()->getParent()->getSection();
         if (def == sect) {
@@ -255,12 +254,12 @@
         }
       }
 
-      if (!pBackend.isSymbolPreemptible(*rel->symInfo()) && sym->hasFragRef() &&
+      if (!pBackend.isSymbolPreemptible(*rel.symInfo()) && sym->hasFragRef() &&
           (pKeptSections.find(
                &sym->fragRef()->frag()->getParent()->getSection()) !=
            pKeptSections.end())) {
         // Mark this reloc as a variable.
-        variable_relocs.push_back(rel);
+        variable_relocs.push_back(&rel);
       } else {
         // TODO: Support inlining merge sections if possible (target-dependent).
         if ((sym->binding() == ResolveInfo::Local) ||
diff --git a/lib/LD/StubFactory.cpp b/lib/LD/StubFactory.cpp
index 75de0cf..6b8c81c 100644
--- a/lib/LD/StubFactory.cpp
+++ b/lib/LD/StubFactory.cpp
@@ -9,6 +9,7 @@
 #include "mcld/LD/StubFactory.h"
 
 #include "mcld/IRBuilder.h"
+#include "mcld/Fragment/FragmentRef.h"
 #include "mcld/Fragment/Relocation.h"
 #include "mcld/Fragment/Stub.h"
 #include "mcld/LD/BranchIsland.h"
@@ -58,77 +59,71 @@
       stub = islands.second->findStub(prototype, pReloc);
     }
 
-    if (stub != NULL) {
-      // reset the branch target to the stub instead!
-      pReloc.setSymInfo(stub->symInfo());
-    } else {
+    if (stub == NULL) {
       // find if there is such a stub in the forward island.
       stub = islands.first->findStub(prototype, pReloc);
-      if (stub != NULL) {
-        // reset the branch target to the stub instead!
-        pReloc.setSymInfo(stub->symInfo());
-      } else {
+      if (stub == NULL) {
         // create a stub from the prototype
         stub = prototype->clone();
 
-        // build a name for stub symbol
-        std::string name("__");
-        name.append(pReloc.symInfo()->name())
-            .append("_")
-            .append(stub->name())
-            .append("@")
-            .append(islands.first->name());
-
-        // create LDSymbol for the stub
-        LDSymbol* symbol =
-            pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
-                name,
-                ResolveInfo::Function,
-                ResolveInfo::Define,
-                ResolveInfo::Local,
-                stub->size(),          // size
-                stub->initSymValue(),  // value
-                FragmentRef::Create(*stub, stub->initSymValue()),
-                ResolveInfo::Default);
-        stub->setSymInfo(symbol->resolveInfo());
-
-        // add relocations of this stub (i.e., set the branch target of the
-        // stub)
-        for (Stub::fixup_iterator it = stub->fixup_begin(),
-                                  ie = stub->fixup_end();
-             it != ie;
-             ++it) {
-          Relocation* reloc =
-              Relocation::Create((*it)->type(),
-                                 *(FragmentRef::Create(*stub, (*it)->offset())),
-                                 (*it)->addend());
-          reloc->setSymInfo(pReloc.symInfo());
-          islands.first->addRelocation(*reloc);
-        }
+        // apply fixups in this new stub
+        stub->applyFixup(pReloc, pBuilder, *islands.first);
 
         // add stub to the forward branch island
         islands.first->addStub(prototype, pReloc, *stub);
-
-        // reset the branch target of the input reloc to this stub instead!
-        pReloc.setSymInfo(stub->symInfo());
       }
     }
   }
   return stub;
 }
 
+Stub* StubFactory::create(FragmentRef& pFragRef,
+                          IRBuilder& pBuilder,
+                          BranchIslandFactory& pBRIslandFactory) {
+  Stub* prototype = findPrototype(pFragRef);
+  if (prototype == NULL) {
+    return NULL;
+  } else {
+    std::pair<BranchIsland*, BranchIsland*> islands =
+        pBRIslandFactory.getIslands(*(pFragRef.frag()));
+    // early exit if we can not find the forward island.
+    if (islands.first == NULL) {
+      return NULL;
+    } else {
+      // create a stub from the prototype
+      Stub* stub = prototype->clone();
+
+      // apply fixups in this new stub
+      stub->applyFixup(pFragRef, pBuilder, *islands.first);
+
+      // add stub to the forward branch island
+      islands.first->addStub(*stub);
+
+      return stub;
+    }  // (islands.first == NULL)
+  }  // if (prototype == NULL)
+}
+
 /// findPrototype - find if there is a registered stub prototype for the given
 /// relocation
 Stub* StubFactory::findPrototype(const Relocation& pReloc,
                                  uint64_t pSource,
-                                 uint64_t pTargetSymValue) {
-  for (StubPoolType::iterator it = m_StubPool.begin(), ie = m_StubPool.end();
-       it != ie;
-       ++it) {
+                                 uint64_t pTargetSymValue) const {
+  for (StubPoolType::const_iterator it = m_StubPool.begin(),
+                                    ie = m_StubPool.end(); it != ie; ++it) {
     if ((*it)->isMyDuty(pReloc, pSource, pTargetSymValue))
       return (*it);
   }
   return NULL;
 }
 
+Stub* StubFactory::findPrototype(const FragmentRef& pFragRef) const {
+  for (StubPoolType::const_iterator it = m_StubPool.begin(),
+                                    ie = m_StubPool.end(); it != ie; ++it) {
+    if ((*it)->isMyDuty(pFragRef))
+      return (*it);
+  }
+  return NULL;
+}
+
 }  // namespace mcld
diff --git a/lib/Object/ObjectLinker.cpp b/lib/Object/ObjectLinker.cpp
index 4d8ffeb..a9813d9 100644
--- a/lib/Object/ObjectLinker.cpp
+++ b/lib/Object/ObjectLinker.cpp
@@ -986,9 +986,8 @@
         break;
     }
   } else {
-    std::memcpy(target_addr,
-                &pReloc.target(),
-                pReloc.size(*m_LDBackend.getRelocator()) / 8);
+    std::memcpy(target_addr, &pReloc.target(),
+                (pReloc.size(*m_LDBackend.getRelocator()) + 7) / 8);
   }
 }
 
diff --git a/lib/Support/Unix/FileSystem.inc b/lib/Support/Unix/FileSystem.inc
index 67fdd73..a429838 100644
--- a/lib/Support/Unix/FileSystem.inc
+++ b/lib/Support/Unix/FileSystem.inc
@@ -15,6 +15,7 @@
 
 #include <dirent.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/mman.h>
diff --git a/lib/Target/AArch64/AArch64CA53Erratum835769Stub.cpp b/lib/Target/AArch64/AArch64CA53Erratum835769Stub.cpp
new file mode 100644
index 0000000..7d10a1e
--- /dev/null
+++ b/lib/Target/AArch64/AArch64CA53Erratum835769Stub.cpp
@@ -0,0 +1,93 @@
+//===- AArch64CA53Erratum835769Stub.cpp -----------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AArch64CA53Erratum835769Stub.h"
+#include "AArch64InsnHelpers.h"
+
+#include "mcld/Fragment/FragmentRef.h"
+#include "mcld/Fragment/Relocation.h"
+#include "mcld/IRBuilder.h"
+#include "mcld/LD/BranchIsland.h"
+#include "mcld/LD/LDSymbol.h"
+#include "mcld/LD/ResolveInfo.h"
+
+#include <llvm/ADT/StringExtras.h>
+#include <llvm/Support/ELF.h>
+
+#include <cassert>
+
+namespace mcld {
+
+//===----------------------------------------------------------------------===//
+// AArch64CA53Erratum835769Stub
+//===----------------------------------------------------------------------===//
+AArch64CA53Erratum835769Stub::AArch64CA53Erratum835769Stub() {
+}
+
+/// for doClone
+AArch64CA53Erratum835769Stub::AArch64CA53Erratum835769Stub(
+    const uint32_t* pData,
+    size_t pSize,
+    const char* pName,
+    const_fixup_iterator pBegin,
+    const_fixup_iterator pEnd)
+    : AArch64CA53ErratumStub(pData, pSize, pName, pBegin, pEnd) {
+}
+
+AArch64CA53Erratum835769Stub::~AArch64CA53Erratum835769Stub() {
+}
+
+bool AArch64CA53Erratum835769Stub::isMyDuty(const FragmentRef& pFragRef) const {
+  unsigned rt;
+  unsigned rt2;
+  bool is_pair;
+  bool is_load;
+  ErratumSequence code;
+  pFragRef.memcpy(&code, sizeof(ErratumSequence), 0);
+
+  if (AArch64InsnHelpers::isMLXL(code.insns[1]) &&
+      AArch64InsnHelpers::isMemOp(code.insns[0], rt, rt2, is_pair, is_load)) {
+    // Any SIMD memory op is independent of the subsequent MLA by definition of
+    // the erratum.
+    if (AArch64InsnHelpers::getBit(code.insns[0], 26) != 0) {
+      return true;
+    }
+
+    // If not SIMD, check for integer memory ops and MLA relationship.
+    unsigned ra = AArch64InsnHelpers::getRa(code.insns[1]);
+    unsigned rm = AArch64InsnHelpers::getRm(code.insns[1]);
+    unsigned rn = AArch64InsnHelpers::getRn(code.insns[1]);
+
+    // If this is a load and there's a true(RAW) dependency, we are safe and
+    // this is not an erratum sequence.
+    if (is_load &&
+        ((rt == ra) ||
+         (rt == rm) ||
+         (rt == rn) ||
+         (is_pair && ((rt2 == ra) || (rt2 == rm) || (rt2 == rn))))) {
+      return false;
+    }
+
+    // We conservatively put out stubs for all other cases (including
+    // writebacks).
+    return true;
+  }
+
+  return false;
+}
+
+Stub* AArch64CA53Erratum835769Stub::doClone() {
+  return new AArch64CA53Erratum835769Stub(getData(),
+                                          size(),
+                                          "erratum_835769_veneer",
+                                          fixup_begin(),
+                                          fixup_end());
+}
+
+}  // namespace mcld
diff --git a/lib/Target/AArch64/AArch64CA53Erratum835769Stub.h b/lib/Target/AArch64/AArch64CA53Erratum835769Stub.h
new file mode 100644
index 0000000..2adadb4
--- /dev/null
+++ b/lib/Target/AArch64/AArch64CA53Erratum835769Stub.h
@@ -0,0 +1,63 @@
+//===- AArch64CA53Erratum835769Stub.h -------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TARGET_AARCH64_AARCH64CA53ERRATUM835769STUB_H_
+#define TARGET_AARCH64_AARCH64CA53ERRATUM835769STUB_H_
+
+#include "AArch64CA53ErratumStub.h"
+
+#include "mcld/Support/Compiler.h"
+#include <llvm/Support/DataTypes.h>
+#include <string>
+#include <vector>
+
+namespace mcld {
+
+class FragmentRef;
+
+class AArch64CA53Erratum835769Stub : public AArch64CA53ErratumStub {
+ public:
+  static constexpr unsigned ErratumInsnOffset = 4;
+
+  struct ErratumSequence {
+    unsigned insns[2];
+  };
+
+ public:
+  AArch64CA53Erratum835769Stub();
+
+  ~AArch64CA53Erratum835769Stub();
+
+  bool isMyDuty(const FragmentRef& pFragRef) const;
+
+  unsigned getErratumInsnOffset() const {
+    return ErratumInsnOffset;
+  }
+
+  unsigned getErratumSequenceSize() const {
+    return sizeof(ErratumSequence);
+  }
+
+ private:
+  /// for doClone
+  AArch64CA53Erratum835769Stub(const uint32_t* pData,
+                               size_t pSize,
+                               const char* pName,
+                               const_fixup_iterator pBegin,
+                               const_fixup_iterator pEnd);
+
+  /// doClone
+  Stub* doClone();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AArch64CA53Erratum835769Stub);
+};
+
+}  // namespace mcld
+
+#endif  // TARGET_AARCH64_AARCH64CA53ERRATUM835769STUB_H_
diff --git a/lib/Target/AArch64/AArch64CA53Erratum843419Stub.cpp b/lib/Target/AArch64/AArch64CA53Erratum843419Stub.cpp
new file mode 100644
index 0000000..978c533
--- /dev/null
+++ b/lib/Target/AArch64/AArch64CA53Erratum843419Stub.cpp
@@ -0,0 +1,93 @@
+//===- AArch64CA53Erratum843419Stub.cpp -----------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AArch64CA53Erratum843419Stub.h"
+#include "AArch64InsnHelpers.h"
+
+#include "mcld/Fragment/FragmentRef.h"
+#include "mcld/Fragment/Relocation.h"
+#include "mcld/IRBuilder.h"
+#include "mcld/LD/BranchIsland.h"
+#include "mcld/LD/LDSection.h"
+#include "mcld/LD/LDSymbol.h"
+#include "mcld/LD/ResolveInfo.h"
+#include "mcld/LD/SectionData.h"
+
+#include <llvm/ADT/StringExtras.h>
+#include <llvm/Support/ELF.h>
+
+#include <cassert>
+
+namespace mcld {
+
+//===----------------------------------------------------------------------===//
+// AArch64CA53Erratum843419Stub
+//===----------------------------------------------------------------------===//
+AArch64CA53Erratum843419Stub::AArch64CA53Erratum843419Stub() {
+}
+
+/// for doClone
+AArch64CA53Erratum843419Stub::AArch64CA53Erratum843419Stub(
+    const uint32_t* pData,
+    size_t pSize,
+    const char* pName,
+    const_fixup_iterator pBegin,
+    const_fixup_iterator pEnd)
+    : AArch64CA53ErratumStub(pData, pSize, pName, pBegin, pEnd) {
+}
+
+AArch64CA53Erratum843419Stub::~AArch64CA53Erratum843419Stub() {
+}
+
+bool AArch64CA53Erratum843419Stub::isErratum843419Sequence(unsigned insn1,
+                                                           unsigned insn2,
+                                                           unsigned insn3) {
+  unsigned rt;
+  unsigned rt2;
+  bool is_pair;
+  bool is_load;
+  return AArch64InsnHelpers::isMemOp(insn2, rt, rt2, is_pair, is_load) &&
+         (!is_pair || (is_pair && !is_load)) &&
+         AArch64InsnHelpers::isLDSTUIMM(insn3) &&
+         (AArch64InsnHelpers::getRn(insn3) == AArch64InsnHelpers::getRd(insn1));
+}
+
+bool AArch64CA53Erratum843419Stub::isMyDuty(const FragmentRef& pFragRef) const {
+  if ((pFragRef.offset() + AArch64InsnHelpers::InsnSize * 3) >
+      pFragRef.frag()->size()) {
+    return false;
+  }
+
+  // The first instruction must be ending at 0xFF8 or 0xFFC.
+  const uint64_t vma = pFragRef.frag()->getParent()->getSection().addr() +
+                       pFragRef.getOutputOffset();
+  const unsigned page_offset = (vma & 0xFFF);
+  if ((page_offset != 0xFF8) && (page_offset != 0xFFC)) {
+    return false;
+  }
+
+  ErratumSequence code;
+  pFragRef.memcpy(&code, AArch64InsnHelpers::InsnSize * 3, 0);
+
+  if (isErratum843419Sequence(code.insns[0], code.insns[1], code.insns[2])) {
+    return true;
+  }
+
+  return false;
+}
+
+Stub* AArch64CA53Erratum843419Stub::doClone() {
+  return new AArch64CA53Erratum843419Stub(getData(),
+                                          size(),
+                                          "erratum_843419_veneer",
+                                          fixup_begin(),
+                                          fixup_end());
+}
+
+}  // namespace mcld
diff --git a/lib/Target/AArch64/AArch64CA53Erratum843419Stub.h b/lib/Target/AArch64/AArch64CA53Erratum843419Stub.h
new file mode 100644
index 0000000..4c3b5b6
--- /dev/null
+++ b/lib/Target/AArch64/AArch64CA53Erratum843419Stub.h
@@ -0,0 +1,68 @@
+//===- AArch64CA53Erratum843419Stub.h -------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TARGET_AARCH64_AARCH64CA53ERRATUM843419STUB_H_
+#define TARGET_AARCH64_AARCH64CA53ERRATUM843419STUB_H_
+
+#include "AArch64CA53ErratumStub.h"
+
+#include "mcld/Support/Compiler.h"
+#include <llvm/Support/DataTypes.h>
+#include <string>
+#include <vector>
+
+namespace mcld {
+
+class FragmentRef;
+
+class AArch64CA53Erratum843419Stub : public AArch64CA53ErratumStub {
+ public:
+  static constexpr unsigned ErratumInsnOffset = 8;
+
+  struct ErratumSequence {
+    unsigned insns[3];
+  };
+
+ public:
+  static bool isErratum843419Sequence(unsigned insn1,
+                                      unsigned insn2,
+                                      unsigned insn3);
+
+ public:
+  AArch64CA53Erratum843419Stub();
+
+  ~AArch64CA53Erratum843419Stub();
+
+  bool isMyDuty(const FragmentRef& pFragRef) const;
+
+  unsigned getErratumInsnOffset() const {
+    return ErratumInsnOffset;
+  }
+
+  unsigned getErratumSequenceSize() const {
+    return sizeof(ErratumSequence);
+  }
+
+ private:
+  /// for doClone
+  AArch64CA53Erratum843419Stub(const uint32_t* pData,
+                               size_t pSize,
+                               const char* pName,
+                               const_fixup_iterator pBegin,
+                               const_fixup_iterator pEnd);
+
+  /// doClone
+  Stub* doClone();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AArch64CA53Erratum843419Stub);
+};
+
+}  // namespace mcld
+
+#endif  // TARGET_AARCH64_AARCH64CA53ERRATUM843419STUB_H_
diff --git a/lib/Target/AArch64/AArch64CA53Erratum843419Stub2.cpp b/lib/Target/AArch64/AArch64CA53Erratum843419Stub2.cpp
new file mode 100644
index 0000000..f498d65
--- /dev/null
+++ b/lib/Target/AArch64/AArch64CA53Erratum843419Stub2.cpp
@@ -0,0 +1,84 @@
+//===- AArch64CA53Erratum843419Stub2.cpp ----------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AArch64CA53Erratum843419Stub.h"
+#include "AArch64CA53Erratum843419Stub2.h"
+#include "AArch64InsnHelpers.h"
+
+#include "mcld/Fragment/FragmentRef.h"
+#include "mcld/Fragment/Relocation.h"
+#include "mcld/IRBuilder.h"
+#include "mcld/LD/BranchIsland.h"
+#include "mcld/LD/LDSection.h"
+#include "mcld/LD/LDSymbol.h"
+#include "mcld/LD/ResolveInfo.h"
+#include "mcld/LD/SectionData.h"
+
+#include <llvm/ADT/StringExtras.h>
+#include <llvm/Support/ELF.h>
+
+#include <cassert>
+
+namespace mcld {
+
+//===----------------------------------------------------------------------===//
+// AArch64CA53Erratum843419Stub2
+//===----------------------------------------------------------------------===//
+AArch64CA53Erratum843419Stub2::AArch64CA53Erratum843419Stub2() {
+}
+
+/// for doClone
+AArch64CA53Erratum843419Stub2::AArch64CA53Erratum843419Stub2(
+    const uint32_t* pData,
+    size_t pSize,
+    const char* pName,
+    const_fixup_iterator pBegin,
+    const_fixup_iterator pEnd)
+    : AArch64CA53ErratumStub(pData, pSize, pName, pBegin, pEnd) {
+}
+
+AArch64CA53Erratum843419Stub2::~AArch64CA53Erratum843419Stub2() {
+}
+
+bool AArch64CA53Erratum843419Stub2::isMyDuty(
+    const FragmentRef& pFragRef) const {
+  if ((pFragRef.offset() + AArch64InsnHelpers::InsnSize * 4) >
+      pFragRef.frag()->size()) {
+    return false;
+  }
+
+  // The first instruction must be ending at 0xFF8 or 0xFFC.
+  const uint64_t vma = pFragRef.frag()->getParent()->getSection().addr() +
+                       pFragRef.getOutputOffset();
+  const unsigned page_offset = (vma & 0xFFF);
+  if ((page_offset != 0xFF8) && (page_offset != 0xFFC)) {
+    return false;
+  }
+
+  ErratumSequence code;
+  pFragRef.memcpy(&code, AArch64InsnHelpers::InsnSize * 4, 0);
+
+  if (AArch64CA53Erratum843419Stub::isErratum843419Sequence(code.insns[0],
+                                                            code.insns[1],
+                                                            code.insns[3])) {
+    return true;
+  }
+
+  return false;
+}
+
+Stub* AArch64CA53Erratum843419Stub2::doClone() {
+  return new AArch64CA53Erratum843419Stub2(getData(),
+                                           size(),
+                                           "erratum_843419_veneer",
+                                           fixup_begin(),
+                                           fixup_end());
+}
+
+}  // namespace mcld
diff --git a/lib/Target/AArch64/AArch64CA53Erratum843419Stub2.h b/lib/Target/AArch64/AArch64CA53Erratum843419Stub2.h
new file mode 100644
index 0000000..53a282b
--- /dev/null
+++ b/lib/Target/AArch64/AArch64CA53Erratum843419Stub2.h
@@ -0,0 +1,63 @@
+//===- AArch64CA53Erratum843419Stub2.h ------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TARGET_AARCH64_AARCH64CA53ERRATUM843419STUB2_H_
+#define TARGET_AARCH64_AARCH64CA53ERRATUM843419STUB2_H_
+
+#include "AArch64CA53ErratumStub.h"
+
+#include "mcld/Support/Compiler.h"
+#include <llvm/Support/DataTypes.h>
+#include <string>
+#include <vector>
+
+namespace mcld {
+
+class FragmentRef;
+
+class AArch64CA53Erratum843419Stub2 : public AArch64CA53ErratumStub {
+ public:
+  static constexpr unsigned ErratumInsnOffset = 12;
+
+  struct ErratumSequence {
+    unsigned insns[4];
+  };
+
+ public:
+  AArch64CA53Erratum843419Stub2();
+
+  ~AArch64CA53Erratum843419Stub2();
+
+  bool isMyDuty(const FragmentRef& pFragRef) const;
+
+  unsigned getErratumInsnOffset() const {
+    return ErratumInsnOffset;
+  }
+
+  unsigned getErratumSequenceSize() const {
+    return sizeof(ErratumSequence);
+  }
+
+ private:
+  /// for doClone
+  AArch64CA53Erratum843419Stub2(const uint32_t* pData,
+                                size_t pSize,
+                                const char* pName,
+                                const_fixup_iterator pBegin,
+                                const_fixup_iterator pEnd);
+
+  /// doClone
+  Stub* doClone();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AArch64CA53Erratum843419Stub2);
+};
+
+}  // namespace mcld
+
+#endif  // TARGET_AARCH64_AARCH64CA53ERRATUM843419STUB2_H_
diff --git a/lib/Target/AArch64/AArch64CA53ErratumStub.cpp b/lib/Target/AArch64/AArch64CA53ErratumStub.cpp
new file mode 100644
index 0000000..9fdc496
--- /dev/null
+++ b/lib/Target/AArch64/AArch64CA53ErratumStub.cpp
@@ -0,0 +1,149 @@
+//===- AArch64CA53ErratumStub.cpp -----------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AArch64CA53ErratumStub.h"
+#include "AArch64InsnHelpers.h"
+#include "AArch64LDBackend.h"
+#include "AArch64RelocationHelpers.h"
+#include "AArch64Relocator.h"
+
+#include "mcld/Fragment/FragmentRef.h"
+#include "mcld/Fragment/Relocation.h"
+#include "mcld/IRBuilder.h"
+#include "mcld/LD/BranchIsland.h"
+#include "mcld/LD/LDSymbol.h"
+#include "mcld/LD/ResolveInfo.h"
+
+#include <llvm/ADT/StringExtras.h>
+#include <llvm/Support/ELF.h>
+
+#include <cassert>
+
+namespace mcld {
+
+//===----------------------------------------------------------------------===//
+// AArch64CA53ErratumStub
+//===----------------------------------------------------------------------===//
+const uint32_t AArch64CA53ErratumStub::TEMPLATE[] = {
+  0x00000000,  // Placeholder for erratum insn
+  0x00000000,  // Palceholder for branch instruction
+};
+
+AArch64CA53ErratumStub::AArch64CA53ErratumStub()
+    : m_pData(NULL),
+      m_Name("erratum__prototype"),
+      m_Size(0x0) {
+  m_pData = TEMPLATE;
+  m_Size = sizeof(TEMPLATE);
+  addFixup(0x0, 0, AArch64Relocator::R_AARCH64_REWRITE_INSN);
+  addFixup(0x4, 0, llvm::ELF::R_AARCH64_JUMP26);
+}
+
+/// for doClone
+AArch64CA53ErratumStub::AArch64CA53ErratumStub(const uint32_t* pData,
+                                               size_t pSize,
+                                               const char* pName,
+                                               const_fixup_iterator pBegin,
+                                               const_fixup_iterator pEnd)
+    : m_pData(pData),
+      m_Name(pName),
+      m_Size(pSize) {
+  for (const_fixup_iterator it = pBegin, ie = pEnd; it != ie; ++it) {
+    addFixup(**it);
+  }
+}
+
+AArch64CA53ErratumStub::~AArch64CA53ErratumStub() {
+}
+
+bool AArch64CA53ErratumStub::isMyDuty(const FragmentRef& pFragRef) const {
+  return false;
+}
+
+void AArch64CA53ErratumStub::applyFixup(FragmentRef& pSrcFragRef,
+                                        IRBuilder& pBuilder,
+                                        BranchIsland& pIsland) {
+  assert(isMyDuty(pSrcFragRef));
+
+  // Build stub symbol name.
+  std::string sym_name("__");
+  sym_name.append(name())
+          .append(llvm::utohexstr(pIsland.numOfStubs()))
+          .append("@")
+          .append(pIsland.name());
+
+  // Create LDSymbol for the stub.
+  LDSymbol* stub_sym =
+      pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
+          sym_name,
+          ResolveInfo::NoType,
+          ResolveInfo::Define,
+          ResolveInfo::Local,
+          size(),
+          initSymValue(),
+          FragmentRef::Create(*this, initSymValue()),
+          ResolveInfo::Default);
+  setSymInfo(stub_sym->resolveInfo());
+
+  // Create the target symbol of the stub to the next instruction of erratum
+  // pattarn.
+  FragmentRef* target = FragmentRef::Create(*pSrcFragRef.frag(),
+                                            pSrcFragRef.offset() +
+                                                getErratumInsnOffset() +
+                                                AArch64InsnHelpers::InsnSize);
+  ResolveInfo* target_info = pBuilder.CreateLocalSymbol(*target);
+
+  // Apply the fixups.
+  fixup_iterator it = fixup_begin();
+  // Rewrite the first instruction as the erratum instruction.
+  Relocation* reloc =
+      Relocation::Create((*it)->type(),
+                         *(FragmentRef::Create(*this, (*it)->offset())),
+                         (*it)->addend());
+  reloc->setSymInfo(target_info);
+
+  std::unique_ptr<unsigned[]> code(new unsigned[getErratumSequenceSize() / 4]);
+  pSrcFragRef.memcpy(code.get(), getErratumSequenceSize(), 0);
+  reloc->target() =
+      code[getErratumInsnOffset() / AArch64InsnHelpers::InsnSize];
+  pIsland.addRelocation(*reloc);
+
+  // Construct the second instruction as a branch to target.
+  ++it;
+  reloc = Relocation::Create((*it)->type(),
+                             *(FragmentRef::Create(*this, (*it)->offset())),
+                             (*it)->addend());
+  reloc->setSymInfo(target_info);
+  reloc->target() = AArch64InsnHelpers::buildBranchInsn();
+  pIsland.addRelocation(*reloc);
+
+  assert((++it) == fixup_end());
+}
+
+const std::string& AArch64CA53ErratumStub::name() const {
+  return m_Name;
+}
+
+const uint32_t* AArch64CA53ErratumStub::getData() const {
+  return m_pData;
+}
+
+const uint8_t* AArch64CA53ErratumStub::getContent() const {
+  return reinterpret_cast<const uint8_t*>(m_pData);
+}
+
+size_t AArch64CA53ErratumStub::size() const {
+  return m_Size;
+}
+
+size_t AArch64CA53ErratumStub::alignment() const {
+  return 8;
+}
+
+}  // namespace mcld
diff --git a/lib/Target/AArch64/AArch64CA53ErratumStub.h b/lib/Target/AArch64/AArch64CA53ErratumStub.h
new file mode 100644
index 0000000..9c9998e
--- /dev/null
+++ b/lib/Target/AArch64/AArch64CA53ErratumStub.h
@@ -0,0 +1,71 @@
+//===- AArch64CA53ErratumStub.h -------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TARGET_AARCH64_AARCH64CA53ERRATUMSTUB_H_
+#define TARGET_AARCH64_AARCH64CA53ERRATUMSTUB_H_
+
+#include "mcld/Fragment/Stub.h"
+#include "mcld/Support/Compiler.h"
+#include <llvm/Support/DataTypes.h>
+#include <string>
+#include <vector>
+
+namespace mcld {
+
+class BranchIsland;
+class FragmentRef;
+class IRBuilder;
+
+class AArch64CA53ErratumStub : public Stub {
+ public:
+  AArch64CA53ErratumStub();
+
+  AArch64CA53ErratumStub(const uint32_t* pData,
+                         size_t pSize,
+                         const char* pName,
+                         const_fixup_iterator pBegin,
+                         const_fixup_iterator pEnd);
+
+  ~AArch64CA53ErratumStub();
+
+  bool isMyDuty(const FragmentRef& pFragRef) const;
+
+  void applyFixup(FragmentRef& pSrcFragRef,
+                  IRBuilder& pBuilder,
+                  BranchIsland& pIsland);
+
+  const std::string& name() const;
+
+  const uint32_t* getData() const;
+
+  const uint8_t* getContent() const;
+
+  size_t size() const;
+
+  size_t alignment() const;
+
+ public:
+  virtual unsigned getErratumSequenceSize() const = 0;
+
+  virtual unsigned getErratumInsnOffset() const = 0;
+
+ private:
+  static const uint32_t TEMPLATE[];
+
+ private:
+  const uint32_t* m_pData;
+  std::string m_Name;
+  size_t m_Size;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AArch64CA53ErratumStub);
+};
+
+}  // namespace mcld
+
+#endif  // TARGET_AARCH64_AARCH64CA53ERRATUMSTUB_H_
diff --git a/lib/Target/AArch64/AArch64GNUInfo.h b/lib/Target/AArch64/AArch64GNUInfo.h
index 491d189..e2a2857 100644
--- a/lib/Target/AArch64/AArch64GNUInfo.h
+++ b/lib/Target/AArch64/AArch64GNUInfo.h
@@ -20,8 +20,6 @@
 
   uint32_t machine() const { return llvm::ELF::EM_AARCH64; }
 
-  uint64_t abiPageSize() const { return 0x10000; }
-
   uint64_t defaultTextSegmentAddr() const { return 0x400000; }
 
   // There are no processor-specific flags so this field shall contain zero.
diff --git a/lib/Target/AArch64/AArch64InsnHelpers.h b/lib/Target/AArch64/AArch64InsnHelpers.h
new file mode 100644
index 0000000..265464f
--- /dev/null
+++ b/lib/Target/AArch64/AArch64InsnHelpers.h
@@ -0,0 +1,278 @@
+//===- AArch64InsnHelpers.h -----------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TARGET_AARCH64_AARCH64INSNHELPERS_H_
+#define TARGET_AARCH64_AARCH64INSNHELPERS_H_
+
+#include "mcld/Support/Compiler.h"
+
+namespace mcld {
+
+class AArch64InsnHelpers {
+ public:
+  typedef uint32_t InsnType;
+
+  static constexpr unsigned InsnSize = 4;
+
+  // Zero register encoding - 31.
+  static constexpr unsigned ZR = 31;
+
+  static unsigned getBits(InsnType insn, int pos, int l) {
+    return (insn >> pos) & ((1 << l) - 1);
+  }
+
+  static unsigned getRt(InsnType insn) {
+    return getBits(insn, 0, 5);
+  }
+
+  static unsigned getRt2(InsnType insn) {
+    return getBits(insn, 10, 5);
+  }
+
+  static unsigned getRa(InsnType insn) {
+    return getBits(insn, 10, 5);
+  }
+
+  static unsigned getRd(InsnType insn) {
+    return getBits(insn, 0, 5);
+  }
+
+  static unsigned getRn(InsnType insn) {
+    return getBits(insn, 5, 5);
+  }
+
+  static unsigned getRm(InsnType insn) {
+    return getBits(insn, 16, 5);
+  }
+
+  static unsigned getBit(InsnType insn, int pos) {
+    return getBits(insn, pos, 1);
+  }
+
+  static unsigned getOp31(InsnType insn) {
+    return getBits(insn, 21, 3);
+  }
+
+  // All ld/st ops. See C4-182 of the ARM ARM. The encoding space for LD_PCREL,
+  // LDST_RO, LDST_UI and LDST_UIMM cover prefetch ops.
+  static bool isLD(InsnType insn) {
+    return (getBit(insn, 22) == 1);
+  }
+
+  static bool isLDST(InsnType insn) {
+    return (((insn) & 0x0a000000) == 0x08000000);
+  }
+
+  static bool isLDSTEX(InsnType insn) {
+    return (((insn) & 0x3f000000) == 0x08000000);
+  }
+
+  static bool isLDSTPCREL(InsnType insn) {
+    return (((insn) & 0x3b000000) == 0x18000000);
+  }
+
+  static bool isLDSTNAP(InsnType insn) {
+    return (((insn) & 0x3b800000) == 0x28000000);
+  }
+
+  static bool isLDSTPPI(InsnType insn) {
+    return (((insn) & 0x3b800000) == 0x28800000);
+  }
+
+  static bool isLDSTPO(InsnType insn) {
+    return (((insn) & 0x3b800000) == 0x29000000);
+  }
+
+  static bool isLDSTPPRE(InsnType insn) {
+    return (((insn) & 0x3b800000) == 0x29800000);
+  }
+
+  static bool isLDSTUI(InsnType insn) {
+    return (((insn) & 0x3b200c00) == 0x38000000);
+  }
+
+  static bool isLDSTPIIMM(InsnType insn) {
+    return (((insn) & 0x3b200c00) == 0x38000400);
+  }
+
+  static bool isLDSTU(InsnType insn) {
+    return (((insn) & 0x3b200c00) == 0x38000800);
+  }
+
+  static bool isLDSTPREIMM(InsnType insn) {
+    return (((insn) & 0x3b200c00) == 0x38000c00);
+  }
+
+  static bool isLDSTRO(InsnType insn) {
+    return (((insn) & 0x3b200c00) == 0x38200800);
+  }
+
+  static bool isLDSTUIMM(InsnType insn) {
+    return (((insn) & 0x3b000000) == 0x39000000);
+  }
+
+  static bool isLDSTSIMDM(InsnType insn) {
+    return (((insn) & 0xbfbf0000) == 0x0c000000);
+  }
+
+  static bool isLDSTSIMDMPI(InsnType insn) {
+    return (((insn) & 0xbfa00000) == 0x0c800000);
+  }
+
+  static bool isLDSTSIMDS(InsnType insn) {
+    return (((insn) & 0xbf9f0000) == 0x0d000000);
+  }
+
+  static bool isLDSTSIMDSPI(InsnType insn) {
+    return (((insn) & 0xbf800000) == 0x0d800000);
+  }
+
+  // Return true if INSN is a mac insn.
+  static bool isMAC(InsnType insn) {
+    return (insn & 0xff000000) == 0x9b000000;
+  }
+
+  // Return true if INSN is multiply-accumulate
+  static bool isMLXL(InsnType insn) {
+    unsigned op31 = getOp31(insn);
+    // Exclude MUL instructions which are encoded as a multiple-accumulate with
+    // RA = XZR
+    if (isMAC(insn) &&
+        ((op31 == 0) || (op31 == 1) || (op31 == 5)) &&
+        getRa(insn) != ZR) {
+      return true;
+    }
+    return false;
+  }
+
+  // Classify an INSN if it is indeed a load/store.
+  //
+  // Return true if INSN is a LD/ST instruction otherwise return false. For
+  // scalar LD/ST instructions is_pair is false, rt is returned and rt2 is set
+  // equal to rt. For LD/ST pair instructions is_pair is true, rt and rt2 are
+  // returned.
+  static bool isMemOp(InsnType insn,
+                      unsigned& rt,
+                      unsigned& rt2,
+                      bool& is_pair,
+                      bool& is_load) {
+    // Bail out quickly if INSN doesn't fall into the the load-store encoding
+    // space.
+    if (!isLDST(insn)) {
+      return false;
+    }
+
+    is_pair = false;
+    is_load = false;
+
+    if (isLDSTEX(insn)) {
+      rt = getRt(insn);
+      rt2 = rt;
+      if (getBit(insn, 21) == 1) {
+        is_pair = true;
+        rt2 = getRt2(insn);
+      }
+      is_load = isLD(insn);
+      return true;
+    } else if (isLDSTNAP(insn) ||
+               isLDSTPPI(insn) ||
+               isLDSTPO(insn) ||
+               isLDSTPPRE(insn)) {
+      rt = getRt(insn);
+      rt2 = getRt2(insn);
+      is_pair = true;
+      is_load = isLD(insn);
+    } else if (isLDSTPCREL(insn) ||
+               isLDSTUI(insn) ||
+               isLDSTPIIMM(insn) ||
+               isLDSTU(insn) ||
+               isLDSTPREIMM(insn) ||
+               isLDSTRO(insn) ||
+               isLDSTUIMM(insn)) {
+      rt = getRt(insn);
+      rt2 = rt;
+      unsigned opc = getBits(insn, 22, 2);
+      unsigned v = getBit(insn, 26);
+      unsigned opc_v = opc | (v << 2);
+      if (isLDSTPCREL(insn) ||
+          ((opc_v == 1) ||
+           (opc_v == 2) ||
+           (opc_v == 3) ||
+           (opc_v == 5) ||
+           (opc_v == 7))) {
+        is_load = true;
+      }
+      return true;
+    } else if (isLDSTSIMDM(insn) || isLDSTSIMDMPI(insn)) {
+      unsigned opcode = (insn >> 12) & 0xf;
+      rt = getRt(insn);
+      is_load = (getBit(insn, 22) != 0);
+      switch (opcode) {
+        case 0:
+        case 2: {
+          rt2 = rt + 3;
+          return true;
+        }
+        case 4:
+        case 6: {
+          rt2 = rt + 2;
+          return true;
+        }
+        case 7: {
+          rt2 = rt;
+          return true;
+        }
+        case 8:
+        case 10: {
+          rt2 = rt + 1;
+          return true;
+        }
+        default: {
+          return false;
+        }
+      }  // switch (opcode)
+    } else if (isLDSTSIMDS(insn) || isLDSTSIMDSPI(insn)) {
+      unsigned r = (insn >> 21) & 1;
+      unsigned opcode = (insn >> 13) & 0x7;
+      rt = getRt(insn);
+      is_load = (getBit(insn, 22) != 0);
+      switch (opcode) {
+        case 0:
+        case 2:
+        case 4:
+        case 6: {
+          rt2 = rt + r;
+          return true;
+        }
+        case 1:
+        case 3:
+        case 5:
+        case 7: {
+          rt2 = rt + ((r == 0) ? 2 : 3);
+          return true;
+        }
+        default: {
+          return false;
+        }
+      }  // switch (opcode)
+    }
+
+    return false;
+  }
+
+  static InsnType buildBranchInsn() {
+    return 0x14000000;
+  }
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(AArch64InsnHelpers);
+};
+
+}  // namespace mcld
+
+#endif  // TARGET_AARCH64_AARCH64INSNHELPERS_H_
diff --git a/lib/Target/AArch64/AArch64LDBackend.cpp b/lib/Target/AArch64/AArch64LDBackend.cpp
index 9224275..b899a5c 100644
--- a/lib/Target/AArch64/AArch64LDBackend.cpp
+++ b/lib/Target/AArch64/AArch64LDBackend.cpp
@@ -7,9 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 #include "AArch64.h"
+#include "AArch64CA53Erratum835769Stub.h"
+#include "AArch64CA53Erratum843419Stub.h"
+#include "AArch64CA53Erratum843419Stub2.h"
 #include "AArch64ELFDynamic.h"
 #include "AArch64GNUInfo.h"
+#include "AArch64InsnHelpers.h"
 #include "AArch64LDBackend.h"
+#include "AArch64LongBranchStub.h"
 #include "AArch64Relocator.h"
 
 #include "mcld/IRBuilder.h"
@@ -281,7 +286,6 @@
     return result;
   }
 
-  // TODO
   return pRegion.size();
 }
 
@@ -304,36 +308,232 @@
   return SHO_UNDEFINED;
 }
 
+void AArch64GNULDBackend::scanErrata(Module& pModule,
+                                     IRBuilder& pBuilder,
+                                     size_t& num_new_stubs,
+                                     size_t& stubs_strlen) {
+  // TODO: Implement AArch64 ErrataStubFactory to create the specific erratum
+  //       stub and simplify the logics.
+  for (Module::iterator sect = pModule.begin(), sectEnd = pModule.end();
+       sect != sectEnd; ++sect) {
+    if (((*sect)->kind() == LDFileFormat::TEXT) && (*sect)->hasSectionData()) {
+      SectionData* sd = (*sect)->getSectionData();
+      for (SectionData::iterator it = sd->begin(), ie = sd->end(); it != ie;
+           ++it) {
+        Fragment* frag = llvm::dyn_cast<RegionFragment>(it);
+        if (frag != NULL) {
+          FragmentRef* frag_ref = FragmentRef::Create(*frag, 0);
+          for (unsigned offset = 0; offset < frag->size();
+               offset += AArch64InsnHelpers::InsnSize) {
+            Stub* stub = getStubFactory()->create(*frag_ref,
+                                                  pBuilder,
+                                                  *getBRIslandFactory());
+            if (stub != NULL) {
+              // A stub symbol should be local
+              assert(stub->symInfo() != NULL && stub->symInfo()->isLocal());
+              const AArch64CA53ErratumStub* erratum_stub =
+                  reinterpret_cast<const AArch64CA53ErratumStub*>(stub);
+              assert(erratum_stub != NULL);
+              // Rewrite the erratum instruction as a branch to the stub.
+              uint64_t offset = frag_ref->offset() +
+                                erratum_stub->getErratumInsnOffset();
+              Relocation* reloc =
+                  Relocation::Create(llvm::ELF::R_AARCH64_JUMP26,
+                                     *(FragmentRef::Create(*frag, offset)),
+                                     /* pAddend */0);
+              reloc->setSymInfo(stub->symInfo());
+              reloc->target() = AArch64InsnHelpers::buildBranchInsn();
+              addExtraRelocation(reloc);
+
+              ++num_new_stubs;
+              stubs_strlen += stub->symInfo()->nameSize() + 1;
+            }
+
+            frag_ref->assign(*frag, offset + AArch64InsnHelpers::InsnSize);
+          }  // for each INSN
+        }
+      }  // for each FRAGMENT
+    }
+  }  // for each TEXT section
+}
+
 bool AArch64GNULDBackend::doRelax(Module& pModule,
                                   IRBuilder& pBuilder,
                                   bool& pFinished) {
-  // TODO
-  return false;
+  assert(getStubFactory() != NULL && getBRIslandFactory() != NULL);
+
+  // Number of new stubs added
+  size_t num_new_stubs = 0;
+  // String lengh to hold new stub symbols
+  size_t stubs_strlen = 0;
+
+  if (config().targets().fixCA53Erratum835769() ||
+      config().targets().fixCA53Erratum843419()) {
+    scanErrata(pModule, pBuilder, num_new_stubs, stubs_strlen);
+  }
+
+  ELFFileFormat* file_format = getOutputFormat();
+  // check branch relocs and create the related stubs if needed
+  Module::obj_iterator input, inEnd = pModule.obj_end();
+  for (input = pModule.obj_begin(); input != inEnd; ++input) {
+    LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
+    for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
+      if (LDFileFormat::Ignore == (*rs)->kind() || !(*rs)->hasRelocData())
+        continue;
+      RelocData::iterator reloc, rEnd = (*rs)->getRelocData()->end();
+      for (reloc = (*rs)->getRelocData()->begin(); reloc != rEnd; ++reloc) {
+        Relocation* relocation = llvm::cast<Relocation>(reloc);
+
+        switch (relocation->type()) {
+          case llvm::ELF::R_AARCH64_CALL26:
+          case llvm::ELF::R_AARCH64_JUMP26: {
+            // calculate the possible symbol value
+            uint64_t sym_value = 0x0;
+            LDSymbol* symbol = relocation->symInfo()->outSymbol();
+            if (symbol->hasFragRef()) {
+              uint64_t value = symbol->fragRef()->getOutputOffset();
+              uint64_t addr =
+                  symbol->fragRef()->frag()->getParent()->getSection().addr();
+              sym_value = addr + value;
+            }
+            if ((relocation->symInfo()->reserved() &
+                 AArch64Relocator::ReservePLT) != 0x0) {
+              // FIXME: we need to find out the address of the specific plt
+              // entry
+              assert(file_format->hasPLT());
+              sym_value = file_format->getPLT().addr();
+            }
+            Stub* stub = getStubFactory()->create(*relocation,  // relocation
+                                                  sym_value,    // symbol value
+                                                  pBuilder,
+                                                  *getBRIslandFactory());
+            if (stub != NULL) {
+              // a stub symbol should be local
+              assert(stub->symInfo() != NULL && stub->symInfo()->isLocal());
+              // reset the branch target of the reloc to this stub instead
+              relocation->setSymInfo(stub->symInfo());
+
+              ++num_new_stubs;
+              stubs_strlen += stub->symInfo()->nameSize() + 1;
+            }
+            break;
+          }
+          default: {
+            break;
+          }
+        }  // end of switch
+      }  // for all relocations
+    }  // for all relocation section
+  }  // for all inputs
+
+  // Find the first fragment w/ invalid offset due to stub insertion.
+  std::vector<Fragment*> invalid_frags;
+  pFinished = true;
+  for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
+                                     island_end = getBRIslandFactory()->end();
+       island != island_end;
+       ++island) {
+    if ((*island).size() > stubGroupSize()) {
+      error(diag::err_no_space_to_place_stubs) << stubGroupSize();
+      return false;
+    }
+
+    if ((*island).numOfStubs() == 0) {
+      continue;
+    }
+
+    Fragment* exit = &*(*island).end();
+    if (exit == (*island).begin()->getParent()->end()) {
+      continue;
+    }
+
+    if (((*island).offset() + (*island).size()) > exit->getOffset()) {
+      if (invalid_frags.empty() ||
+          (invalid_frags.back()->getParent() != (*island).getParent())) {
+        invalid_frags.push_back(exit);
+        pFinished = false;
+      }
+      continue;
+    }
+  }
+
+  // Reset the offset of invalid fragments.
+  for (auto it = invalid_frags.begin(), ie = invalid_frags.end(); it != ie;
+       ++it) {
+    Fragment* invalid = *it;
+    while (invalid != NULL) {
+      invalid->setOffset(invalid->getPrevNode()->getOffset() +
+                         invalid->getPrevNode()->size());
+      invalid = invalid->getNextNode();
+    }
+  }
+
+  // Fix up the size of .symtab, .strtab, and TEXT sections
+  if (num_new_stubs == 0) {
+    return false;
+  } else {
+    switch (config().options().getStripSymbolMode()) {
+      case GeneralOptions::StripSymbolMode::StripAllSymbols:
+      case GeneralOptions::StripSymbolMode::StripLocals:
+        break;
+      default: {
+        LDSection& symtab = file_format->getSymTab();
+        LDSection& strtab = file_format->getStrTab();
+
+        symtab.setSize(symtab.size() +
+                       sizeof(llvm::ELF::Elf64_Sym) * num_new_stubs);
+        symtab.setInfo(symtab.getInfo() + num_new_stubs);
+        strtab.setSize(strtab.size() + stubs_strlen);
+      }
+    }  // switch (config().options().getStripSymbolMode())
+
+    SectionData* prev = NULL;
+    for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
+                                       island_end = getBRIslandFactory()->end();
+         island != island_end;
+         ++island) {
+      SectionData* sd = (*island).begin()->getParent();
+      if ((*island).numOfStubs() != 0) {
+        if (sd != prev) {
+          sd->getSection().setSize(sd->back().getOffset() + sd->back().size());
+        }
+      }
+      prev = sd;
+    }
+    return true;
+  }  // if (num_new_stubs == 0)
 }
 
 bool AArch64GNULDBackend::initTargetStubs() {
-  // TODO
-  return true;
+  StubFactory* factory = getStubFactory();
+  if (factory != NULL) {
+    factory->addPrototype(new AArch64LongBranchStub(config().isCodeIndep()));
+    if (config().targets().fixCA53Erratum835769()) {
+      factory->addPrototype(new AArch64CA53Erratum835769Stub());
+    }
+    if (config().targets().fixCA53Erratum843419()) {
+      factory->addPrototype(new AArch64CA53Erratum843419Stub());
+      factory->addPrototype(new AArch64CA53Erratum843419Stub2());
+    }
+    return true;
+  }
+  return false;
 }
 
 void AArch64GNULDBackend::doCreateProgramHdrs(Module& pModule) {
-  // TODO
 }
 
 bool AArch64GNULDBackend::finalizeTargetSymbols() {
-  // TODO
   return true;
 }
 
 bool AArch64GNULDBackend::mergeSection(Module& pModule,
                                        const Input& pInput,
                                        LDSection& pSection) {
-  // TODO
   return true;
 }
 
 bool AArch64GNULDBackend::readSection(Input& pInput, SectionData& pSD) {
-  // TODO
   return true;
 }
 
diff --git a/lib/Target/AArch64/AArch64LDBackend.h b/lib/Target/AArch64/AArch64LDBackend.h
index b94d535..a8cd52a 100644
--- a/lib/Target/AArch64/AArch64LDBackend.h
+++ b/lib/Target/AArch64/AArch64LDBackend.h
@@ -26,8 +26,11 @@
 ///
 class AArch64GNULDBackend : public GNULDBackend {
  public:
-  static const int64_t AARCH64_MAX_FWD_BRANCH_OFFSET = (((1 << 25) - 1) << 2);
-  static const int64_t AARCH64_MAX_BWD_BRANCH_OFFSET = (-((1 << 25) << 2));
+  static constexpr int64_t MAX_FWD_BRANCH_OFFSET = (((1 << 25) - 1) << 2);
+  static constexpr int64_t MAX_BWD_BRANCH_OFFSET = (-((1 << 25) << 2));
+
+  static constexpr int64_t MAX_ADRP_IMM = (1 << 20) - 1;
+  static constexpr int64_t MIN_ADRP_IMM = -(1 << 20);
 
  public:
   AArch64GNULDBackend(const LinkerConfig& pConfig, GNUInfo* pInfo);
@@ -113,8 +116,13 @@
  private:
   void defineGOTSymbol(IRBuilder& pBuilder);
 
-  int64_t maxFwdBranchOffset() { return AARCH64_MAX_FWD_BRANCH_OFFSET; }
-  int64_t maxBwdBranchOffset() { return AARCH64_MAX_BWD_BRANCH_OFFSET; }
+  int64_t maxFwdBranchOffset() const { return MAX_FWD_BRANCH_OFFSET; }
+  int64_t maxBwdBranchOffset() const { return MAX_BWD_BRANCH_OFFSET; }
+
+  void scanErrata(Module& pModule,
+                  IRBuilder& pBuilder,
+                  size_t& num_new_stubs,
+                  size_t& stubs_strlen);
 
   /// mayRelax - Backends should override this function if they need relaxation
   bool mayRelax() { return true; }
diff --git a/lib/Target/AArch64/AArch64LongBranchStub.cpp b/lib/Target/AArch64/AArch64LongBranchStub.cpp
new file mode 100644
index 0000000..479abca
--- /dev/null
+++ b/lib/Target/AArch64/AArch64LongBranchStub.cpp
@@ -0,0 +1,145 @@
+//===- AArch64LongBranchStub.cpp ------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AArch64LongBranchStub.h"
+#include "AArch64LDBackend.h"
+#include "AArch64RelocationHelpers.h"
+
+#include "mcld/Fragment/Relocation.h"
+#include "mcld/LD/BranchIsland.h"
+#include "mcld/LD/LDSymbol.h"
+#include "mcld/LD/ResolveInfo.h"
+
+#include <llvm/Support/ELF.h>
+
+#include <cassert>
+
+namespace mcld {
+
+//===----------------------------------------------------------------------===//
+// AArch64LongBranchStub
+//===----------------------------------------------------------------------===//
+const uint32_t AArch64LongBranchStub::PIC_TEMPLATE[] = {
+  0x58000090,  // ldr   ip0, 0x10
+  0x10000011,  // adr   ip1, #0
+  0x8b110210,  // add   ip0, ip0, ip1
+  0xd61f0200,  // br    ip0
+  0x00000000,  // .xword <-- R_AARCH64_PREL64(X+12)
+  0x00000000,
+};
+
+const uint32_t AArch64LongBranchStub::TEMPLATE[] = {
+  0x58000050,  // ldr   ip0, 0x8
+  0xd61f0200,  // br    ip0
+  0x00000000,  // .xword <-- R_AARCH64_PREL64(X)
+  0x00000000,
+};
+
+const uint32_t AArch64LongBranchStub::ADRP_TEMPLATE[] = {
+  0x90000010,  // adrp  ip0, X <-- R_AARCH64_ADR_PREL_PG_HI21(X)
+  0x91000210,  // add   ip0, ip0, :lo12:X <-- R_AARCH64_ADD_ABS_LO12_NC(X)
+  0xd61f0200,  // br    ip0
+};
+
+AArch64LongBranchStub::AArch64LongBranchStub(bool pIsOutputPIC)
+    : m_pData(NULL),
+      m_Name("ljmp_prototype"),
+      m_Size(0x0) {
+  if (pIsOutputPIC) {
+    m_pData = PIC_TEMPLATE;
+    m_Size = sizeof(PIC_TEMPLATE);
+    addFixup(0x10, 12, llvm::ELF::R_AARCH64_PREL64);
+  } else {
+    m_pData = TEMPLATE;
+    m_Size = sizeof(TEMPLATE);
+    addFixup(0x8, 0, llvm::ELF::R_AARCH64_PREL64);
+  }
+}
+
+/// for doClone
+AArch64LongBranchStub::AArch64LongBranchStub(const uint32_t* pData,
+                                             size_t pSize,
+                                             const_fixup_iterator pBegin,
+                                             const_fixup_iterator pEnd)
+    : m_pData(pData),
+      m_Name("ljmp_veneer"),
+      m_Size(pSize) {
+  for (const_fixup_iterator it = pBegin, ie = pEnd; it != ie; ++it) {
+    addFixup(**it);
+  }
+}
+
+AArch64LongBranchStub::~AArch64LongBranchStub() {
+}
+
+bool AArch64LongBranchStub::isMyDuty(const Relocation& pReloc,
+                                     uint64_t pSource,
+                                     uint64_t pTargetSymValue) const {
+  assert((pReloc.type() == llvm::ELF::R_AARCH64_CALL26) ||
+         (pReloc.type() == llvm::ELF::R_AARCH64_JUMP26));
+  int64_t dest = pTargetSymValue + pReloc.addend();
+  int64_t branch_offset = dest - pSource;
+  if ((branch_offset > AArch64GNULDBackend::MAX_FWD_BRANCH_OFFSET) ||
+      (branch_offset < AArch64GNULDBackend::MAX_BWD_BRANCH_OFFSET)) {
+    return true;
+  }
+  return false;
+}
+
+static bool isValidForADRP(uint64_t pSource, uint64_t pDest) {
+  int64_t imm = static_cast<int64_t>((helper_get_page_address(pDest) -
+                                      helper_get_page_address(pSource))) >> 12;
+  return ((imm <= AArch64GNULDBackend::MAX_ADRP_IMM) &&
+          (imm >= AArch64GNULDBackend::MIN_ADRP_IMM));
+}
+
+void AArch64LongBranchStub::applyFixup(Relocation& pSrcReloc,
+                                       IRBuilder& pBuilder,
+                                       BranchIsland& pIsland) {
+  // Try to relax the stub itself.
+  LDSymbol* symbol = pSrcReloc.symInfo()->outSymbol();
+  uint64_t dest = symbol->fragRef()->frag()->getParent()->getSection().addr() +
+                  symbol->fragRef()->getOutputOffset();
+  uint64_t src = pIsland.getParent()->getSection().addr() +
+                 pIsland.offset() +
+                 pIsland.size();
+  if (isValidForADRP(src, dest)) {
+    m_pData = ADRP_TEMPLATE;
+    m_Name = "adrp_veneer";
+    m_Size = sizeof(ADRP_TEMPLATE);
+
+    getFixupList().clear();
+    addFixup(0x0, 0, llvm::ELF::R_AARCH64_ADR_PREL_PG_HI21);
+    addFixup(0x4, 0, llvm::ELF::R_AARCH64_ADD_ABS_LO12_NC);
+  }
+
+  Stub::applyFixup(pSrcReloc, pBuilder, pIsland);
+}
+
+const std::string& AArch64LongBranchStub::name() const {
+  return m_Name;
+}
+
+const uint8_t* AArch64LongBranchStub::getContent() const {
+  return reinterpret_cast<const uint8_t*>(m_pData);
+}
+
+size_t AArch64LongBranchStub::size() const {
+  return m_Size;
+}
+
+size_t AArch64LongBranchStub::alignment() const {
+  return 8;
+}
+
+Stub* AArch64LongBranchStub::doClone() {
+  return new AArch64LongBranchStub(m_pData, m_Size, fixup_begin(), fixup_end());
+}
+
+}  // namespace mcld
diff --git a/lib/Target/AArch64/AArch64LongBranchStub.h b/lib/Target/AArch64/AArch64LongBranchStub.h
new file mode 100644
index 0000000..d996040
--- /dev/null
+++ b/lib/Target/AArch64/AArch64LongBranchStub.h
@@ -0,0 +1,70 @@
+//===- AArch64LongBranchStub.h --------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TARGET_AARCH64_AARCH64LONGBRANCHSTUB_H_
+#define TARGET_AARCH64_AARCH64LONGBRANCHSTUB_H_
+
+#include "mcld/Fragment/Stub.h"
+#include "mcld/Support/Compiler.h"
+#include <llvm/Support/DataTypes.h>
+#include <string>
+#include <vector>
+
+namespace mcld {
+
+class BranchIsland;
+class IRBuilder;
+class Relocation;
+
+class AArch64LongBranchStub : public Stub {
+ public:
+  explicit AArch64LongBranchStub(bool pIsOutputPIC);
+
+  ~AArch64LongBranchStub();
+
+  bool isMyDuty(const Relocation& pReloc,
+                uint64_t pSource,
+                uint64_t pTargetSymValue) const;
+
+  void applyFixup(Relocation& pSrcReloc,
+                  IRBuilder& pBuilder,
+                  BranchIsland& pIsland);
+
+  const std::string& name() const;
+
+  const uint8_t* getContent() const;
+
+  size_t size() const;
+
+  size_t alignment() const;
+
+ private:
+  /// for doClone
+  AArch64LongBranchStub(const uint32_t* pData,
+                        size_t pSize,
+                        const_fixup_iterator pBegin,
+                        const_fixup_iterator pEnd);
+
+  /// doClone
+  Stub* doClone();
+
+ private:
+  static const uint32_t PIC_TEMPLATE[];
+  static const uint32_t TEMPLATE[];
+  static const uint32_t ADRP_TEMPLATE[];
+  const uint32_t* m_pData;
+  std::string m_Name;
+  size_t m_Size;
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(AArch64LongBranchStub);
+};
+
+}  // namespace mcld
+
+#endif  // TARGET_AARCH64_AARCH64LONGBRANCHSTUB_H_
diff --git a/lib/Target/AArch64/AArch64RelocationFunctions.h b/lib/Target/AArch64/AArch64RelocationFunctions.h
index 2ed555d..668cc14 100644
--- a/lib/Target/AArch64/AArch64RelocationFunctions.h
+++ b/lib/Target/AArch64/AArch64RelocationFunctions.h
@@ -29,6 +29,7 @@
 
 #define DECL_AARCH64_APPLY_RELOC_FUNC_PTRS(ValueType, MappedType)                              /* NOLINT */\
   ValueType(0x0,   MappedType(&none,             "R_AARCH64_NULL",                        0)), /* NOLINT */\
+  ValueType(0x1,   MappedType(&none,             "R_AARCH64_REWRITE_INSN",               32)), /* NOLINT */\
   ValueType(0x100, MappedType(&none,             "R_AARCH64_NONE",                        0)), /* NOLINT */\
   ValueType(0x101, MappedType(&abs,              "R_AARCH64_ABS64",                      64)), /* NOLINT */\
   ValueType(0x102, MappedType(&abs,              "R_AARCH64_ABS32",                      32)), /* NOLINT */\
diff --git a/lib/Target/AArch64/AArch64Relocator.cpp b/lib/Target/AArch64/AArch64Relocator.cpp
index e59c112..9632f02 100644
--- a/lib/Target/AArch64/AArch64Relocator.cpp
+++ b/lib/Target/AArch64/AArch64Relocator.cpp
@@ -71,8 +71,10 @@
 
 Relocator::Result AArch64Relocator::applyRelocation(Relocation& pRelocation) {
   Relocation::Type type = pRelocation.type();
-  // valid types are 0x0, 0x100-0x239
-  if ((type < 0x100 || type > 0x239) && (type != 0x0)) {
+  // valid types are 0x0, 0x100-1032, and R_AARCH64_REWRITE_INSN
+  if ((type < 0x100 || type > 1032) &&
+      (type != 0x0) &&
+      (type != R_AARCH64_REWRITE_INSN)) {
     return Relocator::Unknown;
   }
   assert(ApplyFunctions.find(type) != ApplyFunctions.end());
@@ -399,6 +401,31 @@
     issueUndefRef(pReloc, pSection, pInput);
 }
 
+bool
+AArch64Relocator::mayHaveFunctionPointerAccess(const Relocation& pReloc) const {
+  switch (pReloc.type()) {
+    case llvm::ELF::R_AARCH64_ADR_PREL_PG_HI21:
+    case llvm::ELF::R_AARCH64_ADR_PREL_PG_HI21_NC:
+    case llvm::ELF::R_AARCH64_ADD_ABS_LO12_NC:
+    case llvm::ELF::R_AARCH64_ADR_GOT_PAGE:
+    case llvm::ELF::R_AARCH64_LD64_GOT_LO12_NC: {
+      return true;
+    }
+    default: {
+      if (pReloc.symInfo()->isLocal()) {
+        // Do not fold any local symbols if building a shared object.
+        return (config().codeGenType() == LinkerConfig::DynObj);
+      } else {
+        // Do not fold any none global defualt symbols if building a shared
+        // object.
+        return ((config().codeGenType() == LinkerConfig::DynObj) &&
+                (pReloc.symInfo()->visibility() != ResolveInfo::Default));
+      }
+    }
+  }
+  return false;
+}
+
 uint32_t AArch64Relocator::getDebugStringOffset(Relocation& pReloc) const {
   if (pReloc.type() != llvm::ELF::R_AARCH64_ABS32)
     error(diag::unsupport_reloc_for_debug_string)
diff --git a/lib/Target/AArch64/AArch64Relocator.h b/lib/Target/AArch64/AArch64Relocator.h
index 3de682c..f9641c0 100644
--- a/lib/Target/AArch64/AArch64Relocator.h
+++ b/lib/Target/AArch64/AArch64Relocator.h
@@ -58,6 +58,11 @@
    */
   enum EntryValue { Default = 0, SymVal = 1 };
 
+  enum {
+    // mcld internal relocation to rewrite an instruction.
+    R_AARCH64_REWRITE_INSN = 1,
+  };
+
  public:
   AArch64Relocator(AArch64GNULDBackend& pParent, const LinkerConfig& pConfig);
   ~AArch64Relocator();
@@ -96,6 +101,10 @@
                       LDSection& pSection,
                       Input& pInput);
 
+  /// mayHaveFunctionPointerAccess - check if the given reloc would possibly
+  /// access a function pointer.
+  virtual bool mayHaveFunctionPointerAccess(const Relocation& pReloc) const;
+
   /// getDebugStringOffset - get the offset from the relocation target. This is
   /// used to get the debug string offset.
   uint32_t getDebugStringOffset(Relocation& pReloc) const;
diff --git a/lib/Target/AArch64/Android.mk b/lib/Target/AArch64/Android.mk
index a143c53..3abc1be 100644
--- a/lib/Target/AArch64/Android.mk
+++ b/lib/Target/AArch64/Android.mk
@@ -1,11 +1,16 @@
 LOCAL_PATH:= $(call my-dir)
 
 mcld_aarch64_target_SRC_FILES := \
+  AArch64CA53Erratum835769Stub.cpp \
+  AArch64CA53Erratum843419Stub2.cpp \
+  AArch64CA53Erratum843419Stub.cpp \
+  AArch64CA53ErratumStub.cpp \
   AArch64Diagnostic.cpp \
   AArch64ELFDynamic.cpp \
   AArch64Emulation.cpp \
   AArch64GOT.cpp \
   AArch64LDBackend.cpp \
+  AArch64LongBranchStub.cpp \
   AArch64PLT.cpp \
   AArch64Relocator.cpp
 
diff --git a/lib/Target/ARM/ARMException.cpp b/lib/Target/ARM/ARMException.cpp
index 3893190..4e354ed 100644
--- a/lib/Target/ARM/ARMException.cpp
+++ b/lib/Target/ARM/ARMException.cpp
@@ -11,7 +11,6 @@
 
 #include "ARMLDBackend.h"
 
-#include "mcld/ADT/ilist_sort.h"
 #include "mcld/Fragment/RegionFragment.h"
 #include "mcld/LD/ELFFileFormat.h"
 #include "mcld/LD/LDContext.h"
@@ -19,17 +18,21 @@
 
 #include <memory>
 
-static const char g_CantUnwindEntry[8] = {
-  // Relocation to text section.
-  0, 0, 0, 0,
-  // EXIDX_CANTUNWIND (little endian.)
-  1, 0, 0, 0,
-};
-
 namespace mcld {
 
+static RegionFragment* findRegionFragment(LDSection& pSection) {
+  SectionData* sectData = pSection.getSectionData();
+  for (SectionData::iterator it = sectData->begin(),
+                             end = sectData->end(); it != end; ++it) {
+    if (it->getKind() == Fragment::Region) {
+      return static_cast<RegionFragment*>(&*it);
+    }
+  }
+  return NULL;
+}
+
 void ARMExData::addInputMap(Input* pInput,
-                            std::unique_ptr<ARMInputExMap>&& pExMap) {
+                            std::unique_ptr<ARMInputExMap> pExMap) {
   assert(m_Inputs.find(pInput) == m_Inputs.end() &&
          "multiple maps for an input");
 
@@ -46,27 +49,17 @@
   }
 }
 
-void ARMGNULDBackend::scanInputExceptionSections(Module& pModule) {
+std::unique_ptr<ARMExData> ARMExData::create(Module& pModule) {
+  std::unique_ptr<ARMExData> exData(new ARMExData());
   for (Module::obj_iterator it = pModule.obj_begin(),
                             end = pModule.obj_end(); it != end; ++it) {
     Input* input = *it;
-    scanInputExceptionSections(pModule, *input);
+    exData->addInputMap(input, ARMInputExMap::create(*input));
   }
+  return exData;
 }
 
-static RegionFragment* findRegionFragment(LDSection& pSection) {
-  SectionData* sectData = pSection.getSectionData();
-  for (SectionData::iterator it = sectData->begin(),
-                             end = sectData->end(); it != end; ++it) {
-    if (it->getKind() == Fragment::Region) {
-      return static_cast<RegionFragment*>(&*it);
-    }
-  }
-  return NULL;
-}
-
-void ARMGNULDBackend::scanInputExceptionSections(Module& pModule,
-                                                 Input& pInput) {
+std::unique_ptr<ARMInputExMap> ARMInputExMap::create(Input& pInput) {
   std::unique_ptr<ARMInputExMap> exMap(new ARMInputExMap());
 
   // Scan the input and collect all related sections.
@@ -74,21 +67,13 @@
   for (LDContext::sect_iterator it = ctx->sectBegin(),
                                 end = ctx->sectEnd(); it != end; ++it) {
     LDSection* sect = *it;
-    llvm::StringRef name(sect->name());
-
-    if (name.startswith(".ARM.exidx")) {
-      ARMExSectionTuple* exTuple = exMap->getOrCreateByExSection(name);
+    if (sect->type() == llvm::ELF::SHT_ARM_EXIDX) {
+      ARMExSectionTuple* exTuple = exMap->getOrCreateByExSection(*sect);
       exTuple->setExIdxSection(sect);
       exTuple->setTextSection(sect->getLink());
-    } else if (name.startswith(".ARM.extab")) {
-      ARMExSectionTuple* exTuple = exMap->getOrCreateByExSection(name);
-      exTuple->setExTabSection(sect);
-    } else if (name.startswith(".rel.ARM.exidx")) {
-      ARMExSectionTuple* exTuple = exMap->getOrCreateByRelExSection(name);
-      exTuple->setRelExIdxSection(sect);
-    } else if (name.startswith(".rel.ARM.extab")) {
-      ARMExSectionTuple* exTuple = exMap->getOrCreateByRelExSection(name);
-      exTuple->setRelExIdxSection(sect);
+      if (sect->getLink() == NULL) {
+        fatal(diag::eh_missing_text_section) << sect->name() << pInput.name();
+      }
     }
   }
 
@@ -100,225 +85,38 @@
     ARMExSectionTuple* exTuple = it->second.get();
     LDSection* const text = exTuple->getTextSection();
     LDSection* const exIdx = exTuple->getExIdxSection();
-    LDSection* const exTab = exTuple->getExTabSection();
-    LDSection* const relExIdx = exTuple->getRelExIdxSection();
-    LDSection* const relExTab = exTuple->getRelExTabSection();
-
-    // Check the .ARM.exidx section.
-    if (!exIdx) {
-      if (exTab) {
-        fatal(diag::eh_missing_exidx_section) << exTab->name() << pInput.name();
-      } else if (relExIdx) {
-        fatal(diag::eh_missing_exidx_section) << relExIdx->name()
-                                              << pInput.name();
-      } else if (relExTab) {
-        fatal(diag::eh_missing_exidx_section) << relExTab->name()
-                                              << pInput.name();
-      } else {
-        llvm_unreachable("unexpected bad exception tuple");
-      }
-    }
-
-    // Check the text section.
-    if (!text) {
-      fatal(diag::eh_missing_text_section) << exIdx->name() << pInput.name();
-    }
 
     // Ignore the exception section if the text section is ignored.
     if ((text->kind() == LDFileFormat::Ignore) ||
         (text->kind() == LDFileFormat::Folded)) {
       // Set the related exception sections as LDFileFormat::Ignore.
       exIdx->setKind(LDFileFormat::Ignore);
-      if (exTab) {
-        exTab->setKind(LDFileFormat::Ignore);
-      }
       // Remove this tuple from the input exception map.
-      exMap->erase(it++);
+      ARMInputExMap::iterator deadIt = it++;
+      exMap->erase(deadIt);
       continue;
     }
 
     // Get RegionFragment from ".text", ".ARM.exidx", and ".ARM.extab" sections.
     RegionFragment* textFrag = findRegionFragment(*text);
     RegionFragment* exIdxFrag = findRegionFragment(*exIdx);
-    RegionFragment* exTabFrag = exTab ? findRegionFragment(*exTab) : NULL;
 
     exTuple->setTextFragment(textFrag);
     exTuple->setExIdxFragment(exIdxFrag);
-    exTuple->setExTabFragment(exTabFrag);
-
-    // Get the RelocData from ".rel.ARM.exidx" and ".rel.ARM.extab" sections.
-    RelocData* exIdxRD = relExIdx ? relExIdx->getRelocData() : NULL;
-    RelocData* exTabRD = relExTab ? relExTab->getRelocData() : NULL;
-
-    exTuple->setExIdxRelocData(exIdxRD);
-    exTuple->setExTabRelocData(exTabRD);
 
     // If there is no region fragment in the .ARM.extab section, then we can
     // skip this tuple.
-    if (!exIdxFrag) {
-      exMap->erase(it++);
+    if (exIdxFrag == NULL) {
+      ARMInputExMap::iterator deadIt = it++;
+      exMap->erase(deadIt);
       continue;
     }
 
-    // TODO: Sort the RelocData w.r.t. the fixup offset.
-
     // Check next tuple
     ++it;
   }
 
-  // Add input map
-  m_ExData.addInputMap(&pInput, std::move(exMap));
-}
-
-class ExIdxFragmentComparator {
- private:
-  const ARMExData& m_ExData;
-
- public:
-  explicit ExIdxFragmentComparator(const ARMExData& pExData)
-      : m_ExData(pExData) {
-  }
-
-  bool operator()(const Fragment& a, const Fragment& b) {
-    ARMExSectionTuple* tupleA = m_ExData.getTupleByExIdx(&a);
-    ARMExSectionTuple* tupleB = m_ExData.getTupleByExIdx(&b);
-
-    Fragment* textFragA = tupleA->getTextFragment();
-    Fragment* textFragB = tupleB->getTextFragment();
-
-    uint64_t addrA = textFragA->getParent()->getSection().addr() +
-                     textFragA->getOffset();
-    uint64_t addrB = textFragB->getParent()->getSection().addr() +
-                     textFragB->getOffset();
-    return (addrA < addrB);
-  }
-};
-
-static mcld::ResolveInfo*
-CreateLocalSymbolToFragmentEnd(mcld::Module& pModule, mcld::Fragment& pFrag) {
-  // Create and add symbol to the name pool.
-  mcld::ResolveInfo* resolveInfo =
-      pModule.getNamePool().createSymbol(/* pName */"",
-                                         /* pIsDyn */false,
-                                         mcld::ResolveInfo::Section,
-                                         mcld::ResolveInfo::Define,
-                                         mcld::ResolveInfo::Local,
-                                         /* pSize */0,
-                                         mcld::ResolveInfo::Hidden);
-  if (resolveInfo == nullptr) {
-    return nullptr;
-  }
-
-  // Create input symbol.
-  mcld::LDSymbol* inputSym = mcld::LDSymbol::Create(*resolveInfo);
-  if (inputSym == nullptr) {
-    return nullptr;
-  }
-
-  inputSym->setFragmentRef(mcld::FragmentRef::Create(pFrag, pFrag.size()));
-  inputSym->setValue(/* pValue */0);
-
-  // The output symbol is simply an alias to the input symbol.
-  resolveInfo->setSymPtr(inputSym);
-
-  return resolveInfo;
-}
-
-void ARMGNULDBackend::rewriteARMExIdxSection(Module& pModule) {
-  if (!m_pEXIDX->hasSectionData()) {
-    // Return if this is empty section.
-    return;
-  }
-
-  SectionData* sectData = m_pEXIDX->getSectionData();
-  SectionData::FragmentListType& list = sectData->getFragmentList();
-
-  // Move the first fragment (align fragment) and last fragment (null fragment)
-  // to temporary list because we would only like to sort the region fragment.
-  SectionData::FragmentListType tmp;
-  {
-    SectionData::iterator first = sectData->begin();
-    SectionData::iterator last = sectData->end();
-    --last;
-
-    assert(first->getKind() == Fragment::Alignment);
-    assert(last->getKind() == Fragment::Null);
-
-    tmp.splice(tmp.end(), list, first);
-    tmp.splice(tmp.end(), list, last);
-  }
-
-  // Sort the region fragments in the .ARM.exidx output section.
-  sort(list, ExIdxFragmentComparator(m_ExData));
-
-  // Fix the coverage of the .ARM.exidx table.
-  llvm::StringRef cantUnwindRegion(g_CantUnwindEntry,
-                                   sizeof(g_CantUnwindEntry));
-
-  SectionData::FragmentListType::iterator it = list.begin();
-  if (it != list.end()) {
-    Fragment* prevTextFrag = m_ExData.getTupleByExIdx(it)->getTextFragment();
-    uint64_t prevTextEnd = prevTextFrag->getParent()->getSection().addr() +
-                           prevTextFrag->getOffset() +
-                           prevTextFrag->size();
-    ++it;
-    while (it != list.end()) {
-      Fragment* currTextFrag = m_ExData.getTupleByExIdx(it)->getTextFragment();
-      uint64_t currTextBegin = currTextFrag->getParent()->getSection().addr() +
-                               currTextFrag->getOffset();
-
-      if (currTextBegin > prevTextEnd) {
-        // Found a gap. Insert a can't unwind entry.
-        RegionFragment* frag = new RegionFragment(cantUnwindRegion, nullptr);
-        frag->setParent(sectData);
-        list.insert(it, frag);
-
-        // Add PREL31 reference to the beginning of the uncovered region.
-        Relocation* reloc =
-            Relocation::Create(static_cast<uint32_t>(llvm::ELF::R_ARM_PREL31),
-                               *FragmentRef::Create(*frag, /* pOffset */0),
-                               /* pAddend */0);
-        reloc->setSymInfo(
-            CreateLocalSymbolToFragmentEnd(pModule, *prevTextFrag));
-        addExtraRelocation(reloc);
-      }
-
-      prevTextEnd = currTextBegin + currTextFrag->size();
-      prevTextFrag = currTextFrag;
-      ++it;
-    }
-
-    // Add a can't unwind entry to terminate .ARM.exidx section.
-    RegionFragment* frag = new RegionFragment(cantUnwindRegion, nullptr);
-    frag->setParent(sectData);
-    list.push_back(frag);
-
-    // Add PREL31 reference to the end of the .text section.
-    Relocation* reloc =
-        Relocation::Create(static_cast<uint32_t>(llvm::ELF::R_ARM_PREL31),
-                           *FragmentRef::Create(*frag, /* pOffset */0),
-                           /* pAddend */0);
-    reloc->setSymInfo(CreateLocalSymbolToFragmentEnd(pModule, *prevTextFrag));
-    addExtraRelocation(reloc);
-  }
-
-  // Add the first and the last fragment back.
-  list.splice(list.begin(), tmp, tmp.begin());
-  list.splice(list.end(), tmp, tmp.begin());
-
-  // Update the fragment offsets.
-  uint64_t offset = 0;
-  for (SectionData::iterator it = sectData->begin(), end = sectData->end();
-       it != end; ++it) {
-    it->setOffset(offset);
-    offset += it->size();
-  }
-
-  // Update the section size.
-  m_pEXIDX->setSize(offset);
-
-  // Rebuild the section header.
-  setOutputSectionAddress(pModule);
+  return exMap;
 }
 
 }  // namespace mcld
diff --git a/lib/Target/ARM/ARMException.h b/lib/Target/ARM/ARMException.h
index 96afbde..157be2e 100644
--- a/lib/Target/ARM/ARMException.h
+++ b/lib/Target/ARM/ARMException.h
@@ -9,8 +9,11 @@
 #ifndef TARGET_ARM_ARMEXCEPTION_H_
 #define TARGET_ARM_ARMEXCEPTION_H_
 
+#include "mcld/LD/LDSection.h"
+
 #include <llvm/ADT/PointerUnion.h>
 #include <llvm/ADT/StringRef.h>
+#include <llvm/Support/ELF.h>
 
 #include <map>
 #include <memory>
@@ -21,6 +24,7 @@
 class Fragment;
 class Input;
 class LDSection;
+class Module;
 class RegionFragment;
 class RelocData;
 
@@ -29,10 +33,7 @@
  public:
   ARMExSectionTuple()
       : m_pTextSection(NULL),
-        m_pExIdxSection(NULL),
-        m_pExTabSection(NULL),
-        m_pRelExIdxSection(NULL),
-        m_pRelExTabSection(NULL) {
+        m_pExIdxSection(NULL) {
   }
 
   LDSection* getTextSection() const {
@@ -43,18 +44,6 @@
     return m_pExIdxSection;
   }
 
-  LDSection* getExTabSection() const {
-    return m_pExTabSection;
-  }
-
-  LDSection* getRelExIdxSection() const {
-    return m_pRelExIdxSection;
-  }
-
-  LDSection* getRelExTabSection() const {
-    return m_pRelExTabSection;
-  }
-
   void setTextSection(LDSection* pSection) {
     m_pTextSection = pSection;
   }
@@ -63,18 +52,6 @@
     m_pExIdxSection = pSection;
   }
 
-  void setExTabSection(LDSection* pSection) {
-    m_pExTabSection = pSection;
-  }
-
-  void setRelExIdxSection(LDSection* pSection) {
-    m_pRelExIdxSection = pSection;
-  }
-
-  void setRelExTabSection(LDSection* pSection) {
-    m_pRelExTabSection = pSection;
-  }
-
   RegionFragment* getTextFragment() const {
     return m_pTextFragment;
   }
@@ -83,18 +60,6 @@
     return m_pExIdxFragment;
   }
 
-  RegionFragment* getExTabFragment() const {
-    return m_pExTabFragment;
-  }
-
-  RelocData* getExIdxRelocData() const {
-    return m_pExIdxRelocData;
-  }
-
-  RelocData* getExTabRelocData() const {
-    return m_pExTabRelocData;
-  }
-
   void setTextFragment(RegionFragment* pFragment) {
     m_pTextFragment = pFragment;
   }
@@ -103,18 +68,6 @@
     m_pExIdxFragment = pFragment;
   }
 
-  void setExTabFragment(RegionFragment* pFragment) {
-    m_pExTabFragment = pFragment;
-  }
-
-  void setExIdxRelocData(RelocData* pRelocData) {
-    m_pExIdxRelocData = pRelocData;
-  }
-
-  void setExTabRelocData(RelocData* pRelocData) {
-    m_pExTabRelocData = pRelocData;
-  }
-
  private:
   // .text section
   union {
@@ -127,102 +80,60 @@
     LDSection*      m_pExIdxSection;
     RegionFragment* m_pExIdxFragment;
   };
-
-  // .ARM.extab section
-  union {
-    LDSection*      m_pExTabSection;
-    RegionFragment* m_pExTabFragment;
-  };
-
-  // .rel.ARM.exidx section
-  union {
-    LDSection*      m_pRelExIdxSection;
-    RelocData*      m_pExIdxRelocData;
-  };
-
-  // .rel.ARM.extab section
-  union {
-    LDSection*      m_pRelExTabSection;
-    RelocData*      m_pExTabRelocData;
-  };
 };
 
-/// ARMInputExMap - ARM exception handling data of an Input
+/// ARMInputExMap - ARM exception handling section mapping of a mcld::Input.
 class ARMInputExMap {
  public:
-  typedef std::map<std::string, std::unique_ptr<ARMExSectionTuple> > NameMap;
-  typedef NameMap::iterator iterator;
-  typedef NameMap::const_iterator const_iterator;
+  typedef std::map<LDSection*, std::unique_ptr<ARMExSectionTuple> > SectMap;
+  typedef SectMap::iterator iterator;
+  typedef SectMap::const_iterator const_iterator;
 
  public:
-  ARMInputExMap() { }
+  // create - Build the exception handling section mapping of a mcld::Input.
+  static std::unique_ptr<ARMInputExMap> create(Input &input);
 
-  /// get - Get the ARMExSectionTuple by the corresponding text section name.
-  /// As an exception, to get the ARMExSectionTuple for .text section, use ""
-  /// as the section name instead.
-  ARMExSectionTuple* get(const char* pName) const {
-    NameMap::const_iterator it = m_NameToExData.find(pName);
-    if (it == m_NameToExData.end()) {
+  /// getByExSection - Get the ARMExSectionTuple by the address of the
+  /// .ARM.exidx section.
+  ARMExSectionTuple* getByExSection(LDSection &pSect) const {
+    assert(pSect.type() == llvm::ELF::SHT_ARM_EXIDX);
+    SectMap::const_iterator it = m_SectToExData.find(&pSect);
+    if (it == m_SectToExData.end()) {
       return NULL;
     }
     return it->second.get();
   }
 
-  ARMExSectionTuple* getByExSection(llvm::StringRef pName) const {
-    assert((pName.startswith(".ARM.exidx") ||
-            pName.startswith(".ARM.extab")) &&
-           "Not a .ARM.exidx section name");
-    return get(pName.data() + sizeof(".ARM.ex***") - 1);
-  }
-
-  ARMExSectionTuple* getByRelExSection(llvm::StringRef pName) const {
-    assert((pName.startswith(".rel.ARM.exidx") ||
-            pName.startswith(".rel.ARM.extab")) &&
-           "Not a .rel.ARM.exidx section name");
-    return get(pName.data() + sizeof(".rel.ARM.ex***") - 1);
-  }
-
   /// getOrCreate - Get an existing or create a new ARMExSectionTuple which is
-  /// associated with the text section name.  As an exception, use "" as the
-  /// section name for .text section.
-  ARMExSectionTuple* getOrCreate(const char* pName) {
-    std::unique_ptr<ARMExSectionTuple>& result = m_NameToExData[pName];
+  /// associated with the address of the .ARM.exidx section.
+  ARMExSectionTuple* getOrCreateByExSection(LDSection &pSect) {
+    assert(pSect.type() == llvm::ELF::SHT_ARM_EXIDX);
+    std::unique_ptr<ARMExSectionTuple>& result = m_SectToExData[&pSect];
     if (!result) {
       result.reset(new ARMExSectionTuple());
     }
     return result.get();
   }
 
-  ARMExSectionTuple* getOrCreateByExSection(llvm::StringRef pName) {
-    assert((pName.startswith(".ARM.exidx") ||
-            pName.startswith(".ARM.extab")) &&
-           "Not a .ARM.exidx section name");
-    return getOrCreate(pName.data() + sizeof(".ARM.ex***") - 1);
-  }
-
-  ARMExSectionTuple* getOrCreateByRelExSection(llvm::StringRef pName) {
-    assert((pName.startswith(".rel.ARM.exidx") ||
-            pName.startswith(".rel.ARM.extab")) &&
-           "Not a .rel.ARM.exidx section name");
-    return getOrCreate(pName.data() + sizeof(".rel.ARM.ex***") - 1);
-  }
-
   /// begin - return the iterator to the begin of the map
-  iterator       begin()       { return m_NameToExData.begin(); }
-  const_iterator begin() const { return m_NameToExData.begin(); }
+  iterator       begin()       { return m_SectToExData.begin(); }
+  const_iterator begin() const { return m_SectToExData.begin(); }
 
   /// end - return the iterator to the end of the map
-  iterator       end()       { return m_NameToExData.end(); }
-  const_iterator end() const { return m_NameToExData.end(); }
+  iterator       end()       { return m_SectToExData.end(); }
+  const_iterator end() const { return m_SectToExData.end(); }
 
   /// erase - remove an entry from the map
-  void erase(iterator it) { m_NameToExData.erase(it); }
+  void erase(iterator it) { m_SectToExData.erase(it); }
 
  private:
-  NameMap m_NameToExData;
+  ARMInputExMap() = default;
+
+ private:
+  SectMap m_SectToExData;
 };
 
-/// ARMExData - ARM exception handling data of a module
+/// ARMExData - ARM exception handling data of a mcld::Module.
 class ARMExData {
  private:
   typedef std::map<Input*, std::unique_ptr<ARMInputExMap> > InputMap;
@@ -230,11 +141,12 @@
   typedef std::map<const Fragment*, ARMExSectionTuple*> ExIdxMap;
 
  public:
-  ARMExData() { }
+  // create - Build the exception handling section mapping of a mcld::Module.
+  static std::unique_ptr<ARMExData> create(Module &module);
 
   // addInputMap - register the ARMInputExMap with associated pInput
   void addInputMap(Input* pInput,
-                   std::unique_ptr<ARMInputExMap>&& pExMap);
+                   std::unique_ptr<ARMInputExMap> pExMap);
 
   // getInputMap - get the ARMInputExMap corresponding to pInput
   ARMInputExMap* getInputMap(Input* pInput) const {
@@ -255,6 +167,9 @@
   }
 
  private:
+  ARMExData() = default;
+
+ private:
   // Map from Input to ARMInputExMap
   InputMap m_Inputs;
 
diff --git a/lib/Target/ARM/ARMLDBackend.cpp b/lib/Target/ARM/ARMLDBackend.cpp
index 0907cac..b2fbfb2 100644
--- a/lib/Target/ARM/ARMLDBackend.cpp
+++ b/lib/Target/ARM/ARMLDBackend.cpp
@@ -10,6 +10,7 @@
 #include "ARMGNUInfo.h"
 #include "ARMELFAttributeData.h"
 #include "ARMELFDynamic.h"
+#include "ARMException.h"
 #include "ARMLDBackend.h"
 #include "ARMRelocator.h"
 #include "ARMToARMStub.h"
@@ -19,16 +20,17 @@
 
 #include "mcld/IRBuilder.h"
 #include "mcld/LinkerConfig.h"
+#include "mcld/ADT/ilist_sort.h"
 #include "mcld/Fragment/AlignFragment.h"
 #include "mcld/Fragment/FillFragment.h"
 #include "mcld/Fragment/NullFragment.h"
 #include "mcld/Fragment/RegionFragment.h"
 #include "mcld/Fragment/Stub.h"
 #include "mcld/LD/BranchIslandFactory.h"
-#include "mcld/LD/LDContext.h"
 #include "mcld/LD/ELFFileFormat.h"
-#include "mcld/LD/ELFSegmentFactory.h"
 #include "mcld/LD/ELFSegment.h"
+#include "mcld/LD/ELFSegmentFactory.h"
+#include "mcld/LD/LDContext.h"
 #include "mcld/LD/StubFactory.h"
 #include "mcld/Object/ObjectBuilder.h"
 #include "mcld/Support/MemoryArea.h"
@@ -45,9 +47,75 @@
 #include <llvm/Support/ELF.h>
 
 #include <cstring>
+#include <vector>
 
 namespace mcld {
 
+/// Fragment data for EXIDX_CANTUNWIND.
+static const char g_CantUnwindEntry[8] = {
+  // Relocation to text section.
+  0, 0, 0, 0,
+  // EXIDX_CANTUNWIND (little endian.)
+  1, 0, 0, 0,
+};
+
+/// Helper function to create a local symbol at the end of the fragment.
+static mcld::ResolveInfo*
+CreateLocalSymbolToFragmentEnd(mcld::Module& pModule, mcld::Fragment& pFrag) {
+  // Create and add symbol to the name pool.
+  mcld::ResolveInfo* resolveInfo =
+      pModule.getNamePool().createSymbol(/* pName */"",
+                                         /* pIsDyn */false,
+                                         mcld::ResolveInfo::Section,
+                                         mcld::ResolveInfo::Define,
+                                         mcld::ResolveInfo::Local,
+                                         /* pSize */0,
+                                         mcld::ResolveInfo::Hidden);
+  if (resolveInfo == nullptr) {
+    return nullptr;
+  }
+
+  // Create input symbol.
+  mcld::LDSymbol* inputSym = mcld::LDSymbol::Create(*resolveInfo);
+  if (inputSym == nullptr) {
+    return nullptr;
+  }
+
+  inputSym->setFragmentRef(mcld::FragmentRef::Create(pFrag, pFrag.size()));
+  inputSym->setValue(/* pValue */0);
+
+  // The output symbol is simply an alias to the input symbol.
+  resolveInfo->setSymPtr(inputSym);
+
+  return resolveInfo;
+}
+
+/// Comparator to sort .ARM.exidx fragments according to the address of the
+/// corresponding .text fragment.
+class ExIdxFragmentComparator {
+ private:
+  const ARMExData& m_pExData;
+
+ public:
+  explicit ExIdxFragmentComparator(const ARMExData& pExData)
+      : m_pExData(pExData) {
+  }
+
+  bool operator()(const Fragment& a, const Fragment& b) {
+    ARMExSectionTuple* tupleA = m_pExData.getTupleByExIdx(&a);
+    ARMExSectionTuple* tupleB = m_pExData.getTupleByExIdx(&b);
+
+    Fragment* textFragA = tupleA->getTextFragment();
+    Fragment* textFragB = tupleB->getTextFragment();
+
+    uint64_t addrA = textFragA->getParent()->getSection().addr() +
+                     textFragA->getOffset();
+    uint64_t addrB = textFragB->getParent()->getSection().addr() +
+                     textFragB->getOffset();
+    return (addrA < addrB);
+  }
+};
+
 //===----------------------------------------------------------------------===//
 // ARMGNULDBackend
 //===----------------------------------------------------------------------===//
@@ -398,7 +466,10 @@
 
 /// preMergeSections - hooks to be executed before merging sections
 void ARMGNULDBackend::preMergeSections(Module& pModule) {
-  scanInputExceptionSections(pModule);
+  // Since the link relationship between .text and .ARM.exidx will be discarded
+  // after merging sections, we have to build the exception handling section
+  // mapping before section merge.
+  m_pExData = ARMExData::create(pModule);
 }
 
 /// postMergeSections - hooks to be executed after merging sections
@@ -634,6 +705,104 @@
   return SHO_UNDEFINED;
 }
 
+void ARMGNULDBackend::rewriteARMExIdxSection(Module& pModule) {
+  if (!m_pEXIDX->hasSectionData()) {
+    // Return if this is empty section.
+    return;
+  }
+
+  SectionData* sectData = m_pEXIDX->getSectionData();
+  SectionData::FragmentListType& list = sectData->getFragmentList();
+
+  // Move the first fragment (align fragment) and last fragment (null fragment)
+  // to temporary list because we would only like to sort the region fragment.
+  SectionData::FragmentListType tmp;
+  {
+    SectionData::iterator first = sectData->begin();
+    SectionData::iterator last = sectData->end();
+    --last;
+
+    assert(first->getKind() == Fragment::Alignment);
+    assert(last->getKind() == Fragment::Null);
+
+    tmp.splice(tmp.end(), list, first);
+    tmp.splice(tmp.end(), list, last);
+  }
+
+  // Sort the region fragments in the .ARM.exidx output section.
+  sort(list, ExIdxFragmentComparator(*m_pExData));
+
+  // Fix the coverage of the .ARM.exidx table.
+  llvm::StringRef cantUnwindRegion(g_CantUnwindEntry,
+                                   sizeof(g_CantUnwindEntry));
+
+  SectionData::FragmentListType::iterator it = list.begin();
+  if (it != list.end()) {
+    Fragment* prevTextFrag = m_pExData->getTupleByExIdx(&*it)->getTextFragment();
+    uint64_t prevTextEnd = prevTextFrag->getParent()->getSection().addr() +
+                           prevTextFrag->getOffset() +
+                           prevTextFrag->size();
+    ++it;
+    while (it != list.end()) {
+      Fragment* currTextFrag =
+          m_pExData->getTupleByExIdx(&*it)->getTextFragment();
+      uint64_t currTextBegin = currTextFrag->getParent()->getSection().addr() +
+                               currTextFrag->getOffset();
+
+      if (currTextBegin > prevTextEnd) {
+        // Found a gap. Insert a can't unwind entry.
+        RegionFragment* frag = new RegionFragment(cantUnwindRegion, nullptr);
+        frag->setParent(sectData);
+        list.insert(it, frag);
+
+        // Add PREL31 reference to the beginning of the uncovered region.
+        Relocation* reloc =
+            Relocation::Create(static_cast<uint32_t>(llvm::ELF::R_ARM_PREL31),
+                               *FragmentRef::Create(*frag, /* pOffset */0),
+                               /* pAddend */0);
+        reloc->setSymInfo(
+            CreateLocalSymbolToFragmentEnd(pModule, *prevTextFrag));
+        addExtraRelocation(reloc);
+      }
+
+      prevTextEnd = currTextBegin + currTextFrag->size();
+      prevTextFrag = currTextFrag;
+      ++it;
+    }
+
+    // Add a can't unwind entry to terminate .ARM.exidx section.
+    RegionFragment* frag = new RegionFragment(cantUnwindRegion, nullptr);
+    frag->setParent(sectData);
+    list.push_back(frag);
+
+    // Add PREL31 reference to the end of the .text section.
+    Relocation* reloc =
+        Relocation::Create(static_cast<uint32_t>(llvm::ELF::R_ARM_PREL31),
+                           *FragmentRef::Create(*frag, /* pOffset */0),
+                           /* pAddend */0);
+    reloc->setSymInfo(CreateLocalSymbolToFragmentEnd(pModule, *prevTextFrag));
+    addExtraRelocation(reloc);
+  }
+
+  // Add the first and the last fragment back.
+  list.splice(list.begin(), tmp, tmp.begin());
+  list.splice(list.end(), tmp, tmp.begin());
+
+  // Update the fragment offsets.
+  uint64_t offset = 0;
+  for (SectionData::iterator it = sectData->begin(), end = sectData->end();
+       it != end; ++it) {
+    it->setOffset(offset);
+    offset += it->size();
+  }
+
+  // Update the section size.
+  m_pEXIDX->setSize(offset);
+
+  // Rebuild the section header.
+  setOutputSectionAddress(pModule);
+}
+
 /// relax - the relaxation pass
 bool ARMGNULDBackend::relax(Module& pModule, IRBuilder& pBuilder) {
   if (!GNULDBackend::relax(pModule, pBuilder)) {
@@ -692,6 +861,10 @@
                                                   pBuilder,
                                                   *getBRIslandFactory());
             if (stub != NULL) {
+              assert(stub->symInfo() != NULL);
+              // reset the branch target of the reloc to this stub instead
+              relocation->setSymInfo(stub->symInfo());
+
               switch (config().options().getStripSymbolMode()) {
                 case GeneralOptions::StripSymbolMode::StripAllSymbols:
                 case GeneralOptions::StripSymbolMode::StripLocals:
@@ -703,12 +876,7 @@
                   LDSection& strtab = file_format->getStrTab();
 
                   // increase the size of .symtab and .strtab if needed
-                  if (config().targets().is32Bits())
-                    symtab.setSize(symtab.size() +
-                                   sizeof(llvm::ELF::Elf32_Sym));
-                  else
-                    symtab.setSize(symtab.size() +
-                                   sizeof(llvm::ELF::Elf64_Sym));
+                  symtab.setSize(symtab.size() + sizeof(llvm::ELF::Elf32_Sym));
                   symtab.setInfo(symtab.getInfo() + 1);
                   strtab.setSize(strtab.size() + stub->symInfo()->nameSize() +
                                  1);
@@ -729,35 +897,62 @@
   }  // for all inputs
 
   // find the first fragment w/ invalid offset due to stub insertion
-  Fragment* invalid = NULL;
+  std::vector<Fragment*> invalid_frags;
   pFinished = true;
   for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
                                      island_end = getBRIslandFactory()->end();
        island != island_end;
        ++island) {
-    if ((*island).end() == file_format->getText().getSectionData()->end())
-      break;
+    if ((*island).size() > stubGroupSize()) {
+      error(diag::err_no_space_to_place_stubs) << stubGroupSize();
+      return false;
+    }
 
-    Fragment* exit = (*island).end();
+    if ((*island).numOfStubs() == 0) {
+      continue;
+    }
+
+    Fragment* exit = &*(*island).end();
+    if (exit == (*island).begin()->getParent()->end()) {
+      continue;
+    }
+
     if (((*island).offset() + (*island).size()) > exit->getOffset()) {
-      invalid = exit;
-      pFinished = false;
-      break;
+      if (invalid_frags.empty() ||
+          (invalid_frags.back()->getParent() != (*island).getParent())) {
+        invalid_frags.push_back(exit);
+        pFinished = false;
+      }
+      continue;
     }
   }
 
   // reset the offset of invalid fragments
-  while (invalid != NULL) {
-    invalid->setOffset(invalid->getPrevNode()->getOffset() +
-                       invalid->getPrevNode()->size());
-    invalid = invalid->getNextNode();
+  for (auto it = invalid_frags.begin(), ie = invalid_frags.end(); it != ie;
+       ++it) {
+    Fragment* invalid = *it;
+    while (invalid != NULL) {
+      invalid->setOffset(invalid->getPrevNode()->getOffset() +
+                         invalid->getPrevNode()->size());
+      invalid = invalid->getNextNode();
+    }
   }
 
-  // reset the size of .text
+  // reset the size of section that has stubs inserted.
   if (isRelaxed) {
-    file_format->getText().setSize(
-        file_format->getText().getSectionData()->back().getOffset() +
-        file_format->getText().getSectionData()->back().size());
+    SectionData* prev = NULL;
+    for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
+                                       island_end = getBRIslandFactory()->end();
+         island != island_end;
+         ++island) {
+      SectionData* sd = (*island).begin()->getParent();
+      if ((*island).numOfStubs() != 0) {
+        if (sd != prev) {
+          sd->getSection().setSize(sd->back().getOffset() + sd->back().size());
+        }
+      }
+      prev = sd;
+    }
   }
   return isRelaxed;
 }
@@ -777,7 +972,7 @@
 }
 
 /// maxFwdBranchOffset
-int64_t ARMGNULDBackend::maxFwdBranchOffset() {
+int64_t ARMGNULDBackend::maxFwdBranchOffset() const {
   if (m_pAttrData->usingThumb2()) {
     return THM2_MAX_FWD_BRANCH_OFFSET;
   } else {
@@ -786,7 +981,7 @@
 }
 
 /// maxBwdBranchOffset
-int64_t ARMGNULDBackend::maxBwdBranchOffset() {
+int64_t ARMGNULDBackend::maxBwdBranchOffset() const {
   if (m_pAttrData->usingThumb2()) {
     return THM2_MAX_BWD_BRANCH_OFFSET;
   } else {
diff --git a/lib/Target/ARM/ARMLDBackend.h b/lib/Target/ARM/ARMLDBackend.h
index d2eae7c..53f4e9f 100644
--- a/lib/Target/ARM/ARMLDBackend.h
+++ b/lib/Target/ARM/ARMLDBackend.h
@@ -17,6 +17,8 @@
 #include "mcld/Target/GNULDBackend.h"
 #include "mcld/Target/OutputRelocSection.h"
 
+#include <memory>
+
 namespace mcld {
 
 class ARMELFAttributeData;
@@ -139,9 +141,9 @@
   void defineGOTSymbol(IRBuilder& pBuilder);
 
   /// maxFwdBranchOffset
-  int64_t maxFwdBranchOffset();
+  int64_t maxFwdBranchOffset() const;
   /// maxBwdBranchOffset
-  int64_t maxBwdBranchOffset();
+  int64_t maxBwdBranchOffset() const;
 
   /// mayRelax - Backends should override this function if they need relaxation
   bool mayRelax() { return true; }
@@ -171,14 +173,6 @@
   /// target-dependent segments
   virtual void doCreateProgramHdrs(Module& pModule);
 
-  /// scanInputExceptionSections - scan exception-related input sections in
-  /// the Module, build the ARMExData, and reclaim GC'ed sections
-  void scanInputExceptionSections(Module& pModule);
-
-  /// scanInputExceptionSections - scan exception-related input sections in
-  /// the Input, build the ARMInputExMap, and reclaim GC'ed sections
-  void scanInputExceptionSections(Module& pModule, Input& pInput);
-
   /// rewriteExceptionSection - rewrite the output .ARM.exidx section.
   void rewriteARMExIdxSection(Module& pModule);
 
@@ -208,9 +202,10 @@
   //  LDSection* m_pDebugOverlay;    // .ARM.debug_overlay
   //  LDSection* m_pOverlayTable;    // .ARM.overlay_table
 
-  // m_ExData - exception handling section data structures
-  ARMExData m_ExData;
+  // m_pExData - exception handling section data structures
+  std::unique_ptr<ARMExData> m_pExData;
 };
+
 }  // namespace mcld
 
 #endif  // TARGET_ARM_ARMLDBACKEND_H_
diff --git a/lib/Target/ARM/ARMRelocator.cpp b/lib/Target/ARM/ARMRelocator.cpp
index fd845cf..0e0a5ce 100644
--- a/lib/Target/ARM/ARMRelocator.cpp
+++ b/lib/Target/ARM/ARMRelocator.cpp
@@ -946,7 +946,8 @@
 
   Relocator::DWord T = getThumbBit(pReloc);
   Relocator::DWord A =
-      helper_thumb32_cond_branch_offset(upper_inst, lower_inst);
+      helper_thumb32_cond_branch_offset(upper_inst, lower_inst) +
+      pReloc.addend();
   Relocator::Address P = pReloc.place();
   Relocator::Address S;
   // if symbol has plt
@@ -1052,7 +1053,8 @@
   uint16_t lower_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1);
 
   Relocator::DWord T = getThumbBit(pReloc);
-  Relocator::DWord A = helper_thumb32_branch_offset(upper_inst, lower_inst);
+  Relocator::DWord A =
+      helper_thumb32_branch_offset(upper_inst, lower_inst) + pReloc.addend();
   Relocator::Address P = pReloc.place();
   Relocator::Address S;
 
diff --git a/lib/Target/GNULDBackend.cpp b/lib/Target/GNULDBackend.cpp
index 79fa25f..ac2cc2b 100644
--- a/lib/Target/GNULDBackend.cpp
+++ b/lib/Target/GNULDBackend.cpp
@@ -59,7 +59,7 @@
 //===----------------------------------------------------------------------===//
 static const std::string simple_c_identifier_allowed_chars =
     "0123456789"
-    "ABCDEFGHIJKLMNOPWRSTUVWXYZ"
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     "abcdefghijklmnopqrstuvwxyz"
     "_";
 
@@ -2175,7 +2175,13 @@
             // Try to align p_vaddr at page boundary if not in script options.
             // To do so will add more padding in file, but can save one page
             // at runtime.
-            alignAddress(vma, (*seg)->align());
+            // Avoid doing this optimization if -z relro is given, because there
+            // seems to be too many padding.
+            if (!config().options().hasRelro()) {
+              alignAddress(vma, (*seg)->align());
+            } else {
+              vma += abiPageSize();
+            }
           }
         }
       } else {
@@ -2876,11 +2882,21 @@
   }
 }
 
+unsigned GNULDBackend::stubGroupSize() const {
+  const unsigned group_size = config().targets().getStubGroupSize();
+  if (group_size == 0) {
+    return m_pInfo->stubGroupSize();
+  } else {
+    return group_size;
+  }
+}
+
 /// initBRIslandFactory - initialize the branch island factory for relaxation
 bool GNULDBackend::initBRIslandFactory() {
   if (m_pBRIslandFactory == NULL) {
-    m_pBRIslandFactory =
-        new BranchIslandFactory(maxFwdBranchOffset(), maxBwdBranchOffset());
+    m_pBRIslandFactory = new BranchIslandFactory(maxFwdBranchOffset(),
+                                                 maxBwdBranchOffset(),
+                                                 stubGroupSize());
   }
   return true;
 }
diff --git a/lib/Target/Hexagon/HexagonLDBackend.cpp b/lib/Target/Hexagon/HexagonLDBackend.cpp
index 5d4d4dc..b46de99 100644
--- a/lib/Target/Hexagon/HexagonLDBackend.cpp
+++ b/lib/Target/Hexagon/HexagonLDBackend.cpp
@@ -34,6 +34,7 @@
 #include <llvm/Support/Casting.h>
 
 #include <cstring>
+#include <vector>
 
 namespace mcld {
 
@@ -577,6 +578,9 @@
                                                   *getBRIslandFactory());
             if (stub != NULL) {
               assert(stub->symInfo() != NULL);
+              // reset the branch target of the reloc to this stub instead
+              relocation->setSymInfo(stub->symInfo());
+
               // increase the size of .symtab and .strtab
               LDSection& symtab = file_format->getSymTab();
               LDSection& strtab = file_format->getStrTab();
@@ -594,35 +598,62 @@
   }
 
   // find the first fragment w/ invalid offset due to stub insertion
-  Fragment* invalid = NULL;
+  std::vector<Fragment*> invalid_frags;
   pFinished = true;
   for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
                                      island_end = getBRIslandFactory()->end();
        island != island_end;
        ++island) {
-    if ((*island).end() == file_format->getText().getSectionData()->end())
-      break;
+    if ((*island).size() > stubGroupSize()) {
+      error(diag::err_no_space_to_place_stubs) << stubGroupSize();
+      return false;
+    }
 
-    Fragment* exit = (*island).end();
+    if ((*island).numOfStubs() == 0) {
+      continue;
+    }
+
+    Fragment* exit = &*(*island).end();
+    if (exit == (*island).begin()->getParent()->end()) {
+      continue;
+    }
+
     if (((*island).offset() + (*island).size()) > exit->getOffset()) {
-      invalid = exit;
-      pFinished = false;
-      break;
+      if (invalid_frags.empty() ||
+          (invalid_frags.back()->getParent() != (*island).getParent())) {
+        invalid_frags.push_back(exit);
+        pFinished = false;
+      }
+      continue;
     }
   }
 
   // reset the offset of invalid fragments
-  while (invalid != NULL) {
-    invalid->setOffset(invalid->getPrevNode()->getOffset() +
-                       invalid->getPrevNode()->size());
-    invalid = invalid->getNextNode();
+  for (auto it = invalid_frags.begin(), ie = invalid_frags.end(); it != ie;
+       ++it) {
+    Fragment* invalid = *it;
+    while (invalid != NULL) {
+      invalid->setOffset(invalid->getPrevNode()->getOffset() +
+                         invalid->getPrevNode()->size());
+      invalid = invalid->getNextNode();
+    }
   }
 
-  // reset the size of .text
+  // reset the size of section that has stubs inserted.
   if (isRelaxed) {
-    file_format->getText().setSize(
-        file_format->getText().getSectionData()->back().getOffset() +
-        file_format->getText().getSectionData()->back().size());
+    SectionData* prev = NULL;
+    for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
+                                       island_end = getBRIslandFactory()->end();
+         island != island_end;
+         ++island) {
+      SectionData* sd = (*island).begin()->getParent();
+      if ((*island).numOfStubs() != 0) {
+        if (sd != prev) {
+          sd->getSection().setSize(sd->back().getOffset() + sd->back().size());
+        }
+      }
+      prev = sd;
+    }
   }
   return isRelaxed;
 }
@@ -720,7 +751,7 @@
     return true;
   }
 
-  int8_t maxGPSize = config().options().getGPSize();
+  int8_t maxGPSize = config().targets().getGPSize();
 
   SymbolCategory::iterator com_sym, com_end;
 
diff --git a/lib/Target/Hexagon/HexagonLDBackend.h b/lib/Target/Hexagon/HexagonLDBackend.h
index 89aea83..8e32062 100644
--- a/lib/Target/Hexagon/HexagonLDBackend.h
+++ b/lib/Target/Hexagon/HexagonLDBackend.h
@@ -157,7 +157,7 @@
   void doCreateProgramHdrs(Module& pModule);
 
   /// maxFwdBranchOffset
-  int64_t maxFwdBranchOffset() { return ~(~0 << 6); }
+  int64_t maxFwdBranchOffset() const { return ~(~0U << 6); }
 
   virtual void setGOTSectionSize(IRBuilder& pBuilder);
 
diff --git a/lib/Target/Hexagon/HexagonPLT.cpp b/lib/Target/Hexagon/HexagonPLT.cpp
index ca9352a..dcd5c94 100644
--- a/lib/Target/Hexagon/HexagonPLT.cpp
+++ b/lib/Target/Hexagon/HexagonPLT.cpp
@@ -35,10 +35,10 @@
 HexagonPLT::HexagonPLT(LDSection& pSection,
                        HexagonGOTPLT& pGOTPLT,
                        const LinkerConfig& pConfig)
-    : PLT(pSection), m_GOTPLT(pGOTPLT), m_Config(pConfig) {
-  assert(LinkerConfig::DynObj == m_Config.codeGenType() ||
-         LinkerConfig::Exec == m_Config.codeGenType() ||
-         LinkerConfig::Binary == m_Config.codeGenType());
+    : PLT(pSection), m_GOTPLT(pGOTPLT) {
+  assert(LinkerConfig::DynObj == pConfig.codeGenType() ||
+         LinkerConfig::Exec == pConfig.codeGenType() ||
+         LinkerConfig::Binary == pConfig.codeGenType());
 
   m_PLT0 = hexagon_plt0;
   m_PLT0Size = sizeof(hexagon_plt0);
diff --git a/lib/Target/Hexagon/HexagonPLT.h b/lib/Target/Hexagon/HexagonPLT.h
index 22f580e..01f16b1 100644
--- a/lib/Target/Hexagon/HexagonPLT.h
+++ b/lib/Target/Hexagon/HexagonPLT.h
@@ -85,8 +85,6 @@
 
   const uint8_t* m_PLT0;
   unsigned int m_PLT0Size;
-
-  const LinkerConfig& m_Config;
 };
 
 class HexagonPLT1 : public PLT::Entry<sizeof(hexagon_plt1)> {
diff --git a/lib/Target/Mips/Android.mk b/lib/Target/Mips/Android.mk
index 0bb2d40..17e93f5 100644
--- a/lib/Target/Mips/Android.mk
+++ b/lib/Target/Mips/Android.mk
@@ -1,6 +1,7 @@
 LOCAL_PATH:= $(call my-dir)
 
 mcld_mips_target_SRC_FILES := \
+  MipsAbiFlags.cpp \
   MipsDiagnostic.cpp  \
   MipsELFDynamic.cpp  \
   MipsEmulation.cpp \
diff --git a/lib/Target/Mips/MipsAbiFlags.cpp b/lib/Target/Mips/MipsAbiFlags.cpp
new file mode 100644
index 0000000..ff17284
--- /dev/null
+++ b/lib/Target/Mips/MipsAbiFlags.cpp
@@ -0,0 +1,298 @@
+//===- MipsAbiFlags.cpp ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "MipsAbiFlags.h"
+
+#include "mcld/Fragment/RegionFragment.h"
+#include "mcld/LD/LDSection.h"
+#include "mcld/LD/SectionData.h"
+#include "mcld/MC/Input.h"
+#include "mcld/Support/MsgHandling.h"
+
+#include <llvm/Support/Casting.h>
+#include <llvm/Support/MipsABIFlags.h>
+
+namespace mcld {
+
+// SHT_MIPS_ABIFLAGS has the same format for both 32/64-bit targets.
+// We do not support linking of big-endian code now so 32-bit LE
+// combination is Okay.
+typedef llvm::object::ELFType<llvm::support::little, false> ELF32LE;
+typedef llvm::object::Elf_Mips_ABIFlags<ELF32LE> ElfMipsAbiFlags;
+
+uint64_t MipsAbiFlags::size() {
+  return sizeof(ElfMipsAbiFlags);
+}
+
+uint64_t MipsAbiFlags::emit(const MipsAbiFlags& pInfo, MemoryRegion& pRegion) {
+  auto* buf = reinterpret_cast<ElfMipsAbiFlags*>(pRegion.begin());
+  buf->version = 0;
+  buf->isa_level = pInfo.m_IsaLevel;
+  buf->isa_rev = pInfo.m_IsaRev;
+  buf->gpr_size = pInfo.m_GprSize;
+  buf->cpr1_size = pInfo.m_Cpr1Size;
+  buf->cpr2_size = pInfo.m_Cpr2Size;
+  buf->fp_abi = pInfo.m_FpAbi;
+  buf->isa_ext = pInfo.m_IsaExt;
+  buf->ases = pInfo.m_Ases;
+  buf->flags1 = pInfo.m_Flags1;
+  buf->flags2 = 0;
+  return size();
+}
+
+bool MipsAbiFlags::fillBySection(const Input& pInput, const LDSection& pSection,
+                                 MipsAbiFlags& mipsAbi) {
+  assert(pSection.type() == llvm::ELF::SHT_MIPS_ABIFLAGS &&
+         "Unexpected section type");
+
+  if (pSection.size() != size()) {
+    error(diag::error_Mips_abiflags_invalid_size) << pInput.name();
+    return false;
+  }
+
+  const SectionData* secData = pSection.getSectionData();
+  if (secData->size() != 2 || !llvm::isa<RegionFragment>(secData->front())) {
+    error(diag::error_Mips_abiflags_invalid_size) << pInput.name();
+    return false;
+  }
+
+  const auto& frag = llvm::cast<RegionFragment>(secData->front());
+  auto* data =
+      reinterpret_cast<const ElfMipsAbiFlags*>(frag.getRegion().data());
+  if (data->version != 0) {
+    error(diag::error_Mips_abiflags_invalid_version) << int(data->version)
+                                                     << pInput.name();
+    return false;
+  }
+
+  mipsAbi.m_IsaLevel = data->isa_level;
+  mipsAbi.m_IsaRev = data->isa_rev;
+  mipsAbi.m_GprSize = data->gpr_size;
+  mipsAbi.m_Cpr1Size = data->cpr1_size;
+  mipsAbi.m_Cpr2Size = data->cpr2_size;
+  mipsAbi.m_FpAbi = data->fp_abi;
+  mipsAbi.m_IsaExt = data->isa_ext;
+  mipsAbi.m_Ases = data->ases;
+  mipsAbi.m_Flags1 = data->flags1;
+  return true;
+}
+
+static unsigned getIsaLevel(uint64_t flags) {
+  switch (flags & llvm::ELF::EF_MIPS_ARCH) {
+    case llvm::ELF::EF_MIPS_ARCH_1:
+      return 1;
+    case llvm::ELF::EF_MIPS_ARCH_2:
+      return 2;
+    case llvm::ELF::EF_MIPS_ARCH_3:
+      return 3;
+    case llvm::ELF::EF_MIPS_ARCH_4:
+      return 4;
+    case llvm::ELF::EF_MIPS_ARCH_5:
+      return 5;
+    case llvm::ELF::EF_MIPS_ARCH_32:
+    case llvm::ELF::EF_MIPS_ARCH_32R2:
+    case llvm::ELF::EF_MIPS_ARCH_32R6:
+      return 32;
+    case llvm::ELF::EF_MIPS_ARCH_64:
+    case llvm::ELF::EF_MIPS_ARCH_64R2:
+    case llvm::ELF::EF_MIPS_ARCH_64R6:
+      return 64;
+    default:
+      // We check ELF flags and show error in case
+      // of unknown value in other place.
+      llvm_unreachable("Unknown MIPS architecture flag");
+  }
+}
+
+static unsigned getIsaRev(uint64_t flags) {
+  switch (flags & llvm::ELF::EF_MIPS_ARCH) {
+    case llvm::ELF::EF_MIPS_ARCH_1:
+    case llvm::ELF::EF_MIPS_ARCH_2:
+    case llvm::ELF::EF_MIPS_ARCH_3:
+    case llvm::ELF::EF_MIPS_ARCH_4:
+    case llvm::ELF::EF_MIPS_ARCH_5:
+      return 0;
+    case llvm::ELF::EF_MIPS_ARCH_32:
+    case llvm::ELF::EF_MIPS_ARCH_64:
+      return 1;
+    case llvm::ELF::EF_MIPS_ARCH_32R2:
+    case llvm::ELF::EF_MIPS_ARCH_64R2:
+      return 2;
+    case llvm::ELF::EF_MIPS_ARCH_32R6:
+    case llvm::ELF::EF_MIPS_ARCH_64R6:
+      return 6;
+    default:
+      // We check ELF flags and show error in case
+      // of unknown value in other place.
+      llvm_unreachable("Unknown MIPS architecture flag");
+  }
+}
+
+static unsigned getIsaExt(uint64_t flags) {
+  switch (flags & llvm::ELF::EF_MIPS_MACH) {
+    case 0:
+      return llvm::Mips::AFL_EXT_NONE;
+    case llvm::ELF::EF_MIPS_MACH_3900: return llvm::Mips::AFL_EXT_3900;
+    case llvm::ELF::EF_MIPS_MACH_4010: return llvm::Mips::AFL_EXT_4010;
+    case llvm::ELF::EF_MIPS_MACH_4100: return llvm::Mips::AFL_EXT_4010;
+    case llvm::ELF::EF_MIPS_MACH_4111: return llvm::Mips::AFL_EXT_4111;
+    case llvm::ELF::EF_MIPS_MACH_4120: return llvm::Mips::AFL_EXT_4120;
+    case llvm::ELF::EF_MIPS_MACH_4650: return llvm::Mips::AFL_EXT_4650;
+    case llvm::ELF::EF_MIPS_MACH_5400: return llvm::Mips::AFL_EXT_5400;
+    case llvm::ELF::EF_MIPS_MACH_5500: return llvm::Mips::AFL_EXT_5500;
+    case llvm::ELF::EF_MIPS_MACH_5900: return llvm::Mips::AFL_EXT_5900;
+    case llvm::ELF::EF_MIPS_MACH_SB1: return llvm::Mips::AFL_EXT_SB1;
+    case llvm::ELF::EF_MIPS_MACH_LS2E: return llvm::Mips::AFL_EXT_LOONGSON_2E;
+    case llvm::ELF::EF_MIPS_MACH_LS2F: return llvm::Mips::AFL_EXT_LOONGSON_2F;
+    case llvm::ELF::EF_MIPS_MACH_LS3A: return llvm::Mips::AFL_EXT_LOONGSON_3A;
+    case llvm::ELF::EF_MIPS_MACH_OCTEON3: return llvm::Mips::AFL_EXT_OCTEON3;
+    case llvm::ELF::EF_MIPS_MACH_OCTEON2: return llvm::Mips::AFL_EXT_OCTEON2;
+    case llvm::ELF::EF_MIPS_MACH_OCTEON: return llvm::Mips::AFL_EXT_OCTEON;
+    case llvm::ELF::EF_MIPS_MACH_XLR: return llvm::Mips::AFL_EXT_XLR;
+    default:
+      // We check ELF flags and show error in case
+      // of unknown value in other place.
+      llvm_unreachable("Unknown MIPS extension flag");
+  }
+}
+
+static bool is32BitElfFlags(uint64_t flags) {
+  if (flags & llvm::ELF::EF_MIPS_32BITMODE)
+    return true;
+
+  uint64_t arch = flags & llvm::ELF::EF_MIPS_ARCH;
+  if (arch == llvm::ELF::EF_MIPS_ARCH_1 ||
+      arch == llvm::ELF::EF_MIPS_ARCH_2 ||
+      arch == llvm::ELF::EF_MIPS_ARCH_32 ||
+      arch == llvm::ELF::EF_MIPS_ARCH_32R2 ||
+      arch == llvm::ELF::EF_MIPS_ARCH_32R6)
+    return true;
+
+  uint64_t abi = flags & llvm::ELF::EF_MIPS_ABI;
+  if (abi == llvm::ELF::EF_MIPS_ABI_O32 || abi == llvm::ELF::EF_MIPS_ABI_EABI32)
+    return true;
+
+  return false;
+}
+
+bool MipsAbiFlags::fillByElfFlags(const Input& pInput, uint64_t elfFlags,
+                                  MipsAbiFlags& mipsAbi) {
+  mipsAbi.m_IsaLevel = getIsaLevel(elfFlags);
+  mipsAbi.m_IsaRev = getIsaRev(elfFlags);
+  mipsAbi.m_IsaExt = getIsaExt(elfFlags);
+
+  mipsAbi.m_GprSize = is32BitElfFlags(elfFlags) ?
+                      llvm::Mips::AFL_REG_32 : llvm::Mips::AFL_REG_64;
+
+  mipsAbi.m_Cpr1Size = llvm::Mips::AFL_REG_NONE;
+  mipsAbi.m_Cpr2Size = llvm::Mips::AFL_REG_NONE;
+  mipsAbi.m_FpAbi = llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY;
+
+  mipsAbi.m_Ases = 0;
+  if (elfFlags & llvm::ELF::EF_MIPS_MICROMIPS)
+    mipsAbi.m_Ases |= llvm::Mips::AFL_ASE_MICROMIPS;
+  if (elfFlags & llvm::ELF::EF_MIPS_ARCH_ASE_M16)
+    mipsAbi.m_Ases |= llvm::Mips::AFL_ASE_MIPS16;
+  if (elfFlags & llvm::ELF::EF_MIPS_ARCH_ASE_MDMX)
+    mipsAbi.m_Ases |= llvm::Mips::AFL_ASE_MDMX;
+
+  mipsAbi.m_Flags1 = 0;
+  return true;
+}
+
+bool MipsAbiFlags::isCompatible(const Input& pInput, const MipsAbiFlags& elf,
+                                const MipsAbiFlags& abi) {
+  unsigned isaRev = abi.m_IsaRev;
+  if (isaRev == 3 || isaRev == 5)
+    isaRev = 2;
+  if (abi.m_IsaLevel != elf.m_IsaLevel || isaRev != elf.m_IsaRev) {
+    warning(diag::warn_Mips_isa_incompatible) << pInput.name();
+    return false;
+  }
+  if (abi.m_IsaExt != elf.m_IsaExt) {
+    warning(diag::warn_Mips_isa_ext_incompatible) << pInput.name();
+    return false;
+  }
+  if ((abi.m_Ases & elf.m_Ases) != elf.m_Ases) {
+    warning(diag::warn_Mips_ases_incompatible) << pInput.name();
+    return false;
+  }
+  return true;
+}
+
+static bool isFpGreater(uint64_t fpA, uint64_t fpB) {
+  if (fpB == llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY)
+    return true;
+  if (fpB == llvm::Mips::Val_GNU_MIPS_ABI_FP_64A &&
+      fpA == llvm::Mips::Val_GNU_MIPS_ABI_FP_64)
+    return true;
+  if (fpB != llvm::Mips::Val_GNU_MIPS_ABI_FP_XX)
+    return false;
+  return fpA == llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE ||
+         fpA == llvm::Mips::Val_GNU_MIPS_ABI_FP_64 ||
+         fpA == llvm::Mips::Val_GNU_MIPS_ABI_FP_64A;
+}
+
+static llvm::StringRef getFpAbiName(uint64_t abi) {
+  switch (abi) {
+    case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY:
+      return "<any>";
+    case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE:
+      return "-mdouble-float";
+    case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE:
+      return "-msingle-float";
+    case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT:
+      return "-msoft-float";
+    case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64:
+      return "-mips32r2 -mfp64 (old)";
+    case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX:
+      return "-mfpxx";
+    case llvm::Mips::Val_GNU_MIPS_ABI_FP_64:
+      return "-mgp32 -mfp64";
+    case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A:
+      return "-mgp32 -mfp64 -mno-odd-spreg";
+    default:
+      return "<unknown>";
+  }
+}
+
+bool MipsAbiFlags::merge(const Input& pInput, MipsAbiFlags& oldFlags,
+                         const MipsAbiFlags& newFlags) {
+  if (oldFlags.m_IsaLevel == 0) {
+    oldFlags = newFlags;
+    return true;
+  }
+
+  if (newFlags.m_IsaLevel > oldFlags.m_IsaLevel)
+    oldFlags.m_IsaLevel = newFlags.m_IsaLevel;
+
+  oldFlags.m_IsaRev = std::max(oldFlags.m_IsaRev, newFlags.m_IsaRev);
+  oldFlags.m_GprSize = std::max(oldFlags.m_GprSize, newFlags.m_GprSize);
+  oldFlags.m_Cpr1Size = std::max(oldFlags.m_Cpr1Size, newFlags.m_Cpr1Size);
+  oldFlags.m_Cpr2Size = std::max(oldFlags.m_Cpr2Size, newFlags.m_Cpr2Size);
+  oldFlags.m_Ases |= newFlags.m_Ases;
+  oldFlags.m_Flags1 |= newFlags.m_Flags1;
+
+  if (oldFlags.m_FpAbi == newFlags.m_FpAbi)
+    return true;
+
+  if (isFpGreater(newFlags.m_FpAbi, oldFlags.m_FpAbi)) {
+    oldFlags.m_FpAbi = newFlags.m_FpAbi;
+    return true;
+  }
+
+  if (isFpGreater(oldFlags.m_FpAbi, newFlags.m_FpAbi))
+    return true;
+
+  llvm::StringRef oldAbiName = getFpAbiName(oldFlags.m_FpAbi);
+  llvm::StringRef newAbiName = getFpAbiName(newFlags.m_FpAbi);
+  warning(diag::warn_Mips_fp_abi_incompatible) << oldAbiName << newAbiName
+                                               << pInput.name();
+  return false;
+}
+}  // namespace mcld
diff --git a/lib/Target/Mips/MipsAbiFlags.h b/lib/Target/Mips/MipsAbiFlags.h
new file mode 100644
index 0000000..4a55b4d
--- /dev/null
+++ b/lib/Target/Mips/MipsAbiFlags.h
@@ -0,0 +1,63 @@
+//===- MipsAbiFlags.h -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TARGET_MIPS_MIPSABIFLAGS_H_
+#define TARGET_MIPS_MIPSABIFLAGS_H_
+
+#include "mcld/Support/MemoryRegion.h"
+
+#include <llvm/ADT/Optional.h>
+#include <llvm/Object/ELFTypes.h>
+
+namespace mcld {
+
+class Input;
+class LDSection;
+
+/** \class MipsAbiFlags
+ *  \brief Representation of .MIPS.abiflags section.
+ */
+class MipsAbiFlags {
+ public:
+  /// size of underlaid ELF section structure
+  static uint64_t size();
+
+  /// write ELF section structure to the memory region
+  static uint64_t emit(const MipsAbiFlags& pInfo, MemoryRegion& pRegion);
+
+  /// fill the structure by the data from the input section
+  static bool fillBySection(const Input& pInput, const LDSection& pSection,
+                            MipsAbiFlags& mipsAbi);
+
+  /// fill the structure by the data from ELF header flags
+  static bool fillByElfFlags(const Input& pInput, uint64_t elfFlags,
+                             MipsAbiFlags& mipsAbi);
+
+  /// check compatibility between two structures
+  static bool isCompatible(const Input& pInput, const MipsAbiFlags& elf,
+                           const MipsAbiFlags& abi);
+
+  /// merge new abi settings to the old structure
+  static bool merge(const Input& pInput, MipsAbiFlags& oldFlags,
+                    const MipsAbiFlags& newFlags);
+
+ private:
+  uint32_t m_IsaLevel;
+  uint32_t m_IsaRev;
+  uint32_t m_IsaExt;
+  uint32_t m_GprSize;
+  uint32_t m_Cpr1Size;
+  uint32_t m_Cpr2Size;
+  uint32_t m_FpAbi;
+  uint32_t m_Ases;
+  uint32_t m_Flags1;
+};
+
+}  // namespace mcld
+
+#endif  // TARGET_MIPS_MIPSABIFLAGS_H_
diff --git a/lib/Target/Mips/MipsGNUInfo.cpp b/lib/Target/Mips/MipsGNUInfo.cpp
index 132e9c3..9a1804f 100644
--- a/lib/Target/Mips/MipsGNUInfo.cpp
+++ b/lib/Target/Mips/MipsGNUInfo.cpp
@@ -14,15 +14,15 @@
 // MipsGNUInfo
 //===----------------------------------------------------------------------===//
 MipsGNUInfo::MipsGNUInfo(const llvm::Triple& pTriple)
-    : GNUInfo(pTriple), m_ABIVersion(0), m_PICFlags(0) {
+    : GNUInfo(pTriple), m_ABIVersion(0), m_ElfFlags(0) {
 }
 
 void MipsGNUInfo::setABIVersion(uint8_t ver) {
   m_ABIVersion = ver;
 }
 
-void MipsGNUInfo::setPICFlags(uint64_t flags) {
-  m_PICFlags = flags;
+void MipsGNUInfo::setElfFlags(uint64_t flags) {
+  m_ElfFlags = flags;
 }
 
 uint32_t MipsGNUInfo::machine() const {
@@ -41,14 +41,7 @@
 }
 
 uint64_t MipsGNUInfo::flags() const {
-  uint64_t val = llvm::ELF::EF_MIPS_NOREORDER | m_PICFlags;
-
-  if (m_Triple.isArch32Bit())
-    val |= llvm::ELF::EF_MIPS_ARCH_32R2 | llvm::ELF::EF_MIPS_ABI_O32;
-  else
-    val |= llvm::ELF::EF_MIPS_ARCH_64R2;
-
-  return val;
+  return m_ElfFlags;
 }
 
 const char* MipsGNUInfo::entry() const {
diff --git a/lib/Target/Mips/MipsGNUInfo.h b/lib/Target/Mips/MipsGNUInfo.h
index 673c39a..9ab907f 100644
--- a/lib/Target/Mips/MipsGNUInfo.h
+++ b/lib/Target/Mips/MipsGNUInfo.h
@@ -18,7 +18,7 @@
   explicit MipsGNUInfo(const llvm::Triple& pTriple);
 
   void setABIVersion(uint8_t ver);
-  void setPICFlags(uint64_t flags);
+  void setElfFlags(uint64_t flags);
 
   // GNUInfo
   uint32_t machine() const;
@@ -31,7 +31,7 @@
 
  private:
   uint8_t m_ABIVersion;
-  uint64_t m_PICFlags;
+  uint64_t m_ElfFlags;
 };
 
 }  // namespace mcld
diff --git a/lib/Target/Mips/MipsGOT.cpp b/lib/Target/Mips/MipsGOT.cpp
index 85d89c7..4234e87 100644
--- a/lib/Target/Mips/MipsGOT.cpp
+++ b/lib/Target/Mips/MipsGOT.cpp
@@ -33,14 +33,19 @@
 MipsGOT::GOTMultipart::GOTMultipart(size_t local, size_t global)
     : m_LocalNum(local),
       m_GlobalNum(global),
+      m_TLSNum(0),
+      m_TLSDynNum(0),
       m_ConsumedLocal(0),
       m_ConsumedGlobal(0),
+      m_ConsumedTLS(0),
       m_pLastLocal(NULL),
-      m_pLastGlobal(NULL) {
+      m_pLastGlobal(NULL),
+      m_pLastTLS(NULL) {
 }
 
 bool MipsGOT::GOTMultipart::isConsumed() const {
-  return m_LocalNum == m_ConsumedLocal && m_GlobalNum == m_ConsumedGlobal;
+  return m_LocalNum == m_ConsumedLocal && m_GlobalNum == m_ConsumedGlobal &&
+         m_TLSNum == m_ConsumedTLS;
 }
 
 void MipsGOT::GOTMultipart::consumeLocal() {
@@ -56,6 +61,13 @@
   m_pLastGlobal = m_pLastGlobal->getNextNode();
 }
 
+void MipsGOT::GOTMultipart::consumeTLS(Relocation::Type pType) {
+  assert(m_ConsumedTLS < m_TLSNum &&
+         "Consumed too many TLS GOT entries");
+  m_ConsumedTLS += pType == llvm::ELF::R_MIPS_TLS_GOTTPREL ? 1 : 2;
+  m_pLastTLS = m_pLastTLS->getNextNode();
+}
+
 //===----------------------------------------------------------------------===//
 // MipsGOT::LocalEntry
 //===----------------------------------------------------------------------===//
@@ -79,7 +91,11 @@
 // MipsGOT
 //===----------------------------------------------------------------------===//
 MipsGOT::MipsGOT(LDSection& pSection)
-    : GOT(pSection), m_pInput(NULL), m_CurrentGOTPart(0) {
+    : GOT(pSection),
+      m_pInput(NULL),
+      m_HasTLSLdmSymbol(false),
+      m_CurrentGOTPart(0),
+      m_GotTLSLdmEntry(nullptr) {
 }
 
 uint64_t MipsGOT::getGPDispAddress() const {
@@ -108,6 +124,8 @@
     reserve(it->m_LocalNum);
     it->m_pLastGlobal = &m_SectionData->back();
     reserve(it->m_GlobalNum);
+    it->m_pLastTLS = &m_SectionData->back();
+    reserve(it->m_TLSNum);
 
     if (it == m_MultipartList.begin()) {
       // Reserve entries in the second part of the primary GOT.
@@ -122,6 +140,9 @@
       for (size_t i = 0; i < count; ++i)
         pRelDyn.reserveEntry();
     }
+
+    for (size_t i = 0; i < it->m_TLSDynNum; ++i)
+      pRelDyn.reserveEntry();
   }
 }
 
@@ -147,6 +168,8 @@
   m_InputGlobalSymbols.clear();
   m_MergedLocalSymbols.clear();
   m_InputLocalSymbols.clear();
+  m_InputTLSGdSymbols.clear();
+  m_HasTLSLdmSymbol = false;
 }
 
 void MipsGOT::changeInput() {
@@ -262,6 +285,39 @@
   return true;
 }
 
+bool MipsGOT::reserveTLSGdEntry(ResolveInfo& pInfo) {
+  if (m_InputTLSGdSymbols.count(&pInfo))
+    return false;
+
+  m_InputTLSGdSymbols.insert(&pInfo);
+  m_MultipartList.back().m_TLSNum += 2;
+  m_MultipartList.back().m_TLSDynNum += 2;
+
+  return true;
+}
+
+bool MipsGOT::reserveTLSLdmEntry() {
+  if (m_HasTLSLdmSymbol)
+    return false;
+
+  m_HasTLSLdmSymbol = true;
+  m_MultipartList.back().m_TLSNum += 2;
+  m_MultipartList.back().m_TLSDynNum += 1;
+
+  return true;
+}
+
+bool MipsGOT::reserveTLSGotEntry(ResolveInfo& pInfo) {
+  if (m_InputTLSGotSymbols.count(&pInfo))
+    return false;
+
+  m_InputTLSGotSymbols.insert(&pInfo);
+  m_MultipartList.back().m_TLSNum += 1;
+  m_MultipartList.back().m_TLSDynNum += 1;
+
+  return true;
+}
+
 bool MipsGOT::isPrimaryGOTConsumed() {
   return m_CurrentGOTPart > 0;
 }
@@ -290,6 +346,18 @@
   return m_MultipartList[m_CurrentGOTPart].m_pLastGlobal;
 }
 
+Fragment* MipsGOT::consumeTLS(Relocation::Type pType) {
+  assert(m_CurrentGOTPart < m_MultipartList.size() &&
+         "GOT number is out of range!");
+
+  if (m_MultipartList[m_CurrentGOTPart].isConsumed())
+    ++m_CurrentGOTPart;
+
+  m_MultipartList[m_CurrentGOTPart].consumeTLS(pType);
+
+  return m_MultipartList[m_CurrentGOTPart].m_pLastTLS;
+}
+
 uint64_t MipsGOT::getGPAddr(const Input& pInput) const {
   uint64_t gotSize = 0;
   for (MultipartListType::const_iterator it = m_MultipartList.begin(),
@@ -333,6 +401,50 @@
   return it->second;
 }
 
+void MipsGOT::recordTLSEntry(const ResolveInfo* pInfo, Fragment* pEntry,
+                             Relocation::Type pType) {
+  if (pType == llvm::ELF::R_MIPS_TLS_LDM) {
+    m_GotTLSLdmEntry = pEntry;
+  } else if (pType == llvm::ELF::R_MIPS_TLS_GD) {
+    GotEntryKey key;
+    key.m_GOTPage = m_CurrentGOTPart;
+    key.m_pInfo = pInfo;
+    key.m_Addend = 0;
+    m_GotTLSGdEntriesMap[key] = pEntry;
+  } else if (pType == llvm::ELF::R_MIPS_TLS_GOTTPREL) {
+    GotEntryKey key;
+    key.m_GOTPage = m_CurrentGOTPart;
+    key.m_pInfo = pInfo;
+    key.m_Addend = 0;
+    m_GotTLSGotEntriesMap[key] = pEntry;
+  } else {
+    llvm_unreachable("Unexpected relocation");
+  }
+}
+
+Fragment* MipsGOT::lookupTLSEntry(const ResolveInfo* pInfo,
+                                  Relocation::Type pType) {
+  if (pType == llvm::ELF::R_MIPS_TLS_LDM)
+    return m_GotTLSLdmEntry;
+  if (pType == llvm::ELF::R_MIPS_TLS_GD) {
+    GotEntryKey key;
+    key.m_GOTPage = m_CurrentGOTPart;
+    key.m_pInfo = pInfo;
+    key.m_Addend = 0;
+    GotEntryMapType::iterator it = m_GotTLSGdEntriesMap.find(key);
+    return it == m_GotTLSGdEntriesMap.end() ? nullptr : it->second;
+  }
+  if (pType == llvm::ELF::R_MIPS_TLS_GOTTPREL) {
+    GotEntryKey key;
+    key.m_GOTPage = m_CurrentGOTPart;
+    key.m_pInfo = pInfo;
+    key.m_Addend = 0;
+    GotEntryMapType::iterator it = m_GotTLSGotEntriesMap.find(key);
+    return it == m_GotTLSGotEntriesMap.end() ? nullptr : it->second;
+  }
+  llvm_unreachable("Unexpected relocation");
+}
+
 void MipsGOT::recordLocalEntry(const ResolveInfo* pInfo,
                                Relocation::DWord pAddend,
                                Fragment* pEntry) {
diff --git a/lib/Target/Mips/MipsGOT.h b/lib/Target/Mips/MipsGOT.h
index 409347b..fc0e540 100644
--- a/lib/Target/Mips/MipsGOT.h
+++ b/lib/Target/Mips/MipsGOT.h
@@ -50,6 +50,9 @@
                          int reloc,
                          Relocation::DWord pAddend);
   bool reserveGlobalEntry(ResolveInfo& pInfo);
+  bool reserveTLSGdEntry(ResolveInfo& pInfo);
+  bool reserveTLSGotEntry(ResolveInfo& pInfo);
+  bool reserveTLSLdmEntry();
 
   size_t getLocalNum() const;   ///< number of local symbols in primary GOT
   size_t getGlobalNum() const;  ///< total number of global symbols
@@ -58,6 +61,7 @@
 
   Fragment* consumeLocal();
   Fragment* consumeGlobal();
+  Fragment* consumeTLS(Relocation::Type pType);
 
   uint64_t getGPAddr(const Input& pInput) const;
   uint64_t getGPRelOffset(const Input& pInput, const Fragment& pEntry) const;
@@ -65,6 +69,10 @@
   void recordGlobalEntry(const ResolveInfo* pInfo, Fragment* pEntry);
   Fragment* lookupGlobalEntry(const ResolveInfo* pInfo);
 
+  void recordTLSEntry(const ResolveInfo* pInfo, Fragment* pEntry,
+                      Relocation::Type pType);
+  Fragment* lookupTLSEntry(const ResolveInfo* pInfo, Relocation::Type pType);
+
   void recordLocalEntry(const ResolveInfo* pInfo,
                         Relocation::DWord pAddend,
                         Fragment* pEntry);
@@ -103,12 +111,16 @@
 
     size_t m_LocalNum;   ///< number of reserved local entries
     size_t m_GlobalNum;  ///< number of reserved global entries
+    size_t m_TLSNum;     ///< number of reserved TLS entries
+    size_t m_TLSDynNum;  ///< number of reserved TLS related dynamic relocations
 
     size_t m_ConsumedLocal;   ///< consumed local entries
     size_t m_ConsumedGlobal;  ///< consumed global entries
+    size_t m_ConsumedTLS;     ///< consumed TLS entries
 
     Fragment* m_pLastLocal;   ///< the last consumed local entry
     Fragment* m_pLastGlobal;  ///< the last consumed global entry
+    Fragment* m_pLastTLS;     ///< the last consumed TLS entry
 
     InputSetType m_Inputs;
 
@@ -116,6 +128,7 @@
 
     void consumeLocal();
     void consumeGlobal();
+    void consumeTLS(Relocation::Type pType);
   };
 
   /** \class LocalEntry
@@ -153,6 +166,12 @@
   SymbolSetType m_MergedGlobalSymbols;
   // Global symbols from the current input.
   SymbolUniqueMapType m_InputGlobalSymbols;
+  // Set of symbols referenced by TLS GD relocations.
+  SymbolSetType m_InputTLSGdSymbols;
+  // Set of symbols referenced by TLS GOTTPREL relocation.
+  SymbolSetType m_InputTLSGotSymbols;
+  // There is a symbol referenced by TLS LDM relocations.
+  bool m_HasTLSLdmSymbol;
   // Local symbols merged to the current GOT
   // except symbols from the current input.
   LocalSymbolSetType m_MergedLocalSymbols;
@@ -191,6 +210,9 @@
   typedef std::map<GotEntryKey, Fragment*> GotEntryMapType;
   GotEntryMapType m_GotLocalEntriesMap;
   GotEntryMapType m_GotGlobalEntriesMap;
+  GotEntryMapType m_GotTLSGdEntriesMap;
+  GotEntryMapType m_GotTLSGotEntriesMap;
+  Fragment* m_GotTLSLdmEntry;
 };
 
 /** \class Mips32GOT
diff --git a/lib/Target/Mips/MipsGOTPLT.cpp b/lib/Target/Mips/MipsGOTPLT.cpp
index 745b258..dab4be5 100644
--- a/lib/Target/Mips/MipsGOTPLT.cpp
+++ b/lib/Target/Mips/MipsGOTPLT.cpp
@@ -25,12 +25,6 @@
   // Create header's entries.
   new GOTPLTEntry(0, m_SectionData);
   new GOTPLTEntry(0, m_SectionData);
-  m_Last = ++m_SectionData->begin();
-}
-
-void MipsGOTPLT::reserve(size_t pNum) {
-  for (size_t i = 0; i < pNum; ++i)
-    new GOTPLTEntry(0, m_SectionData);
 }
 
 uint64_t MipsGOTPLT::emit(MemoryRegion& pRegion) {
@@ -45,11 +39,8 @@
   return result;
 }
 
-Fragment* MipsGOTPLT::consume() {
-  ++m_Last;
-  assert(m_Last != m_SectionData->end() &&
-         "There is no reserved GOTPLT entries");
-  return &(*m_Last);
+Fragment* MipsGOTPLT::create() {
+  return new GOTPLTEntry(0, m_SectionData);
 }
 
 bool MipsGOTPLT::hasGOT1() const {
diff --git a/lib/Target/Mips/MipsGOTPLT.h b/lib/Target/Mips/MipsGOTPLT.h
index f5cd909..b585707 100644
--- a/lib/Target/Mips/MipsGOTPLT.h
+++ b/lib/Target/Mips/MipsGOTPLT.h
@@ -31,17 +31,9 @@
 
   uint64_t emit(MemoryRegion& pRegion);
 
-  Fragment* consume();
+  Fragment* create();
 
   void applyAllGOTPLT(uint64_t pltAddr);
-
- public:
-  // GOT
-  void reserve(size_t pNum = 1);
-
- private:
-  // the last consumed entry.
-  SectionData::iterator m_Last;
 };
 
 }  // namespace mcld
diff --git a/lib/Target/Mips/MipsLA25Stub.cpp b/lib/Target/Mips/MipsLA25Stub.cpp
index 3127b37..9bcf85f 100644
--- a/lib/Target/Mips/MipsLA25Stub.cpp
+++ b/lib/Target/Mips/MipsLA25Stub.cpp
@@ -19,13 +19,6 @@
     0x00000000   // nop
 };
 
-enum {
-  // Fake relocations for patching LA25 stubs.
-  R_MIPS_LA25_LUI = 200,
-  R_MIPS_LA25_J = 201,
-  R_MIPS_LA25_ADD = 202
-};
-
 }  // anonymous namespace
 
 namespace mcld {
@@ -39,9 +32,9 @@
       m_Name("MipsLA25_Prototype"),
       m_pData(STUB),
       m_Size(sizeof(STUB)) {
-  addFixup(0, 0x0, R_MIPS_LA25_LUI);
-  addFixup(4, 0x0, R_MIPS_LA25_J);
-  addFixup(8, 0x0, R_MIPS_LA25_ADD);
+  addFixup(0, 0x0, llvm::ELF::R_MIPS_HI16);
+  addFixup(4, 0x0, llvm::ELF::R_MIPS_26);
+  addFixup(8, 0x0, llvm::ELF::R_MIPS_LO16);
 }
 
 MipsLA25Stub::MipsLA25Stub(const MipsGNULDBackend& pTarget,
diff --git a/lib/Target/Mips/MipsLDBackend.cpp b/lib/Target/Mips/MipsLDBackend.cpp
index c629edd..d4e8145 100644
--- a/lib/Target/Mips/MipsLDBackend.cpp
+++ b/lib/Target/Mips/MipsLDBackend.cpp
@@ -16,11 +16,14 @@
 #include "mcld/IRBuilder.h"
 #include "mcld/LinkerConfig.h"
 #include "mcld/Module.h"
+#include "mcld/Fragment/AlignFragment.h"
 #include "mcld/Fragment/FillFragment.h"
 #include "mcld/LD/BranchIslandFactory.h"
 #include "mcld/LD/LDContext.h"
 #include "mcld/LD/StubFactory.h"
 #include "mcld/LD/ELFFileFormat.h"
+#include "mcld/LD/ELFSegment.h"
+#include "mcld/LD/ELFSegmentFactory.h"
 #include "mcld/MC/Attribute.h"
 #include "mcld/Object/ObjectBuilder.h"
 #include "mcld/Support/MemoryRegion.h"
@@ -30,9 +33,13 @@
 #include "mcld/Target/OutputRelocSection.h"
 
 #include <llvm/ADT/Triple.h>
+#include <llvm/Object/ELFTypes.h>
 #include <llvm/Support/Casting.h>
 #include <llvm/Support/ELF.h>
 #include <llvm/Support/Host.h>
+#include <llvm/Support/MipsABIFlags.h>
+
+#include <vector>
 
 namespace mcld {
 
@@ -50,6 +57,7 @@
       m_pRelPlt(NULL),
       m_pRelDyn(NULL),
       m_pDynamic(NULL),
+      m_pAbiFlags(NULL),
       m_pGOTSymbol(NULL),
       m_pPLTSymbol(NULL),
       m_pGpDispSymbol(NULL) {
@@ -99,6 +107,17 @@
   // initialize .rel.dyn
   LDSection& reldyn = file_format->getRelDyn();
   m_pRelDyn = new OutputRelocSection(pModule, reldyn);
+
+  // initialize .sdata
+  m_psdata = pBuilder.CreateSection(
+      ".sdata", LDFileFormat::Target, llvm::ELF::SHT_PROGBITS,
+      llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE | llvm::ELF::SHF_MIPS_GPREL,
+      4);
+
+  // initialize .MIPS.abiflags
+  m_pAbiFlags = pBuilder.CreateSection(".MIPS.abiflags", LDFileFormat::Target,
+                                       llvm::ELF::SHT_MIPS_ABIFLAGS,
+                                       llvm::ELF::SHF_ALLOC, 4);
 }
 
 void MipsGNULDBackend::initTargetSymbols(IRBuilder& pBuilder, Module& pModule) {
@@ -163,6 +182,9 @@
   if (!config().isCodeStatic() && m_pDynamic == NULL)
     m_pDynamic = new MipsELFDynamic(*this, config());
 
+  if (m_pAbiInfo.hasValue())
+    m_pAbiFlags->setSize(m_pAbiInfo->size());
+
   // set .got size
   // when building shared object, the .got section is must.
   if (LinkerConfig::Object != config().codeGenType()) {
@@ -219,18 +241,6 @@
   }
 
   m_pInfo.setABIVersion(m_pPLT && m_pPLT->hasPLT1() ? 1 : 0);
-
-  // FIXME: (simon) We need to iterate all input sections
-  // check that flags are consistent and merge them properly.
-  uint64_t picFlags = llvm::ELF::EF_MIPS_CPIC;
-  if (config().targets().triple().isArch64Bit()) {
-    picFlags |= llvm::ELF::EF_MIPS_PIC;
-  } else {
-    if (LinkerConfig::DynObj == config().codeGenType())
-      picFlags |= llvm::ELF::EF_MIPS_PIC;
-  }
-
-  m_pInfo.setPICFlags(picFlags);
 }
 
 /// dynamic - the dynamic section of the target machine.
@@ -265,6 +275,60 @@
     return m_pGOTPLT->emit(pRegion);
   }
 
+  if (&pSection == m_pAbiFlags && m_pAbiInfo.hasValue())
+    return MipsAbiFlags::emit(*m_pAbiInfo, pRegion);
+
+  if (&pSection == m_psdata && m_psdata->hasSectionData()) {
+    const SectionData* sect_data = pSection.getSectionData();
+    SectionData::const_iterator frag_iter, frag_end = sect_data->end();
+    uint8_t* out_offset = pRegion.begin();
+    for (frag_iter = sect_data->begin(); frag_iter != frag_end; ++frag_iter) {
+      size_t size = frag_iter->size();
+      switch (frag_iter->getKind()) {
+        case Fragment::Fillment: {
+          const FillFragment& fill_frag = llvm::cast<FillFragment>(*frag_iter);
+          if (fill_frag.getValueSize() == 0) {
+            // virtual fillment, ignore it.
+            break;
+          }
+          memset(out_offset, fill_frag.getValue(), fill_frag.size());
+          break;
+        }
+        case Fragment::Region: {
+          const RegionFragment& region_frag =
+              llvm::cast<RegionFragment>(*frag_iter);
+          const char* start = region_frag.getRegion().begin();
+          memcpy(out_offset, start, size);
+          break;
+        }
+        case Fragment::Alignment: {
+          const AlignFragment& align_frag =
+              llvm::cast<AlignFragment>(*frag_iter);
+          uint64_t count = size / align_frag.getValueSize();
+          switch (align_frag.getValueSize()) {
+            case 1u:
+              std::memset(out_offset, align_frag.getValue(), count);
+              break;
+            default:
+              llvm::report_fatal_error(
+                  "unsupported value size for align fragment emission yet.\n");
+              break;
+          }  // end switch
+          break;
+        }
+        case Fragment::Null: {
+          assert(0x0 == size);
+          break;
+        }
+        default:
+          llvm::report_fatal_error("unsupported fragment type.\n");
+          break;
+      }  // end switch
+      out_offset += size;
+    }
+    return pRegion.size();
+  }
+
   fatal(diag::unrecognized_output_sectoin) << pSection.name()
                                            << "mclinker@googlegroups.com";
   return 0;
@@ -335,10 +399,55 @@
 
 namespace mcld {
 
-bool MipsGNULDBackend::readSection(Input& pInput, SectionData& pSD) {
-  llvm::StringRef name(pSD.getSection().name());
+static const char* ArchName(uint64_t flagBits) {
+  switch (flagBits) {
+    case llvm::ELF::EF_MIPS_ARCH_1:
+      return "mips1";
+    case llvm::ELF::EF_MIPS_ARCH_2:
+      return "mips2";
+    case llvm::ELF::EF_MIPS_ARCH_3:
+      return "mips3";
+    case llvm::ELF::EF_MIPS_ARCH_4:
+      return "mips4";
+    case llvm::ELF::EF_MIPS_ARCH_5:
+      return "mips5";
+    case llvm::ELF::EF_MIPS_ARCH_32:
+      return "mips32";
+    case llvm::ELF::EF_MIPS_ARCH_64:
+      return "mips64";
+    case llvm::ELF::EF_MIPS_ARCH_32R2:
+      return "mips32r2";
+    case llvm::ELF::EF_MIPS_ARCH_64R2:
+      return "mips64r2";
+    case llvm::ELF::EF_MIPS_ARCH_32R6:
+      return "mips32r6";
+    case llvm::ELF::EF_MIPS_ARCH_64R6:
+      return "mips64r6";
+    default:
+      return "Unknown Arch";
+  }
+}
 
-  if (name.startswith(".sdata")) {
+void MipsGNULDBackend::mergeFlags(Input& pInput, const char* ELF_hdr) {
+  bool isTarget64Bit = config().targets().triple().isArch64Bit();
+  bool isInput64Bit = ELF_hdr[llvm::ELF::EI_CLASS] == llvm::ELF::ELFCLASS64;
+
+  if (isTarget64Bit != isInput64Bit) {
+    fatal(diag::error_Mips_incompatible_class)
+        << (isTarget64Bit ? "ELFCLASS64" : "ELFCLASS32")
+        << (isInput64Bit ? "ELFCLASS64" : "ELFCLASS32") << pInput.name();
+    return;
+  }
+
+  m_ElfFlagsMap[&pInput] =
+      isInput64Bit ?
+          reinterpret_cast<const llvm::ELF::Elf64_Ehdr*>(ELF_hdr)->e_flags :
+          reinterpret_cast<const llvm::ELF::Elf32_Ehdr*>(ELF_hdr)->e_flags;
+}
+
+bool MipsGNULDBackend::readSection(Input& pInput, SectionData& pSD) {
+  if ((pSD.getSection().flag() & llvm::ELF::SHF_MIPS_GPREL) ||
+      (pSD.getSection().type() == llvm::ELF::SHT_MIPS_ABIFLAGS)) {
     uint64_t offset = pInput.fileOffset() + pSD.getSection().offset();
     uint64_t size = pSD.getSection().size();
 
@@ -449,6 +558,12 @@
   if (file_format->hasPLT() && (&pSectHdr == &file_format->getPLT()))
     return SHO_PLT;
 
+  if (&pSectHdr == m_psdata)
+    return SHO_SMALL_DATA;
+
+  if (&pSectHdr == m_pAbiFlags)
+    return SHO_RO_NOTE;
+
   return SHO_UNDEFINED;
 }
 
@@ -558,6 +673,14 @@
   return true;
 }
 
+uint64_t MipsGNULDBackend::getTPOffset(const Input& pInput) const {
+  return m_TpOffsetMap.lookup(&pInput);
+}
+
+uint64_t MipsGNULDBackend::getDTPOffset(const Input& pInput) const {
+  return m_DtpOffsetMap.lookup(&pInput);
+}
+
 uint64_t MipsGNULDBackend::getGP0(const Input& pInput) const {
   return m_GP0Map.lookup(&pInput);
 }
@@ -620,7 +743,24 @@
 /// doCreateProgramHdrs - backend can implement this function to create the
 /// target-dependent segments
 void MipsGNULDBackend::doCreateProgramHdrs(Module& pModule) {
-  // TODO
+  if (!m_pAbiFlags || m_pAbiFlags->size() == 0)
+    return;
+
+  // create PT_MIPS_ABIFLAGS segment
+  ELFSegmentFactory::iterator sit =
+      elfSegmentTable().find(llvm::ELF::PT_INTERP, 0x0, 0x0);
+  if (sit == elfSegmentTable().end())
+    sit = elfSegmentTable().find(llvm::ELF::PT_PHDR, 0x0, 0x0);
+  if (sit == elfSegmentTable().end())
+    sit = elfSegmentTable().begin();
+  else
+    ++sit;
+
+  ELFSegment* abiSeg = elfSegmentTable().insert(sit,
+                                                llvm::ELF::PT_MIPS_ABIFLAGS,
+                                                llvm::ELF::PF_R);
+  abiSeg->setAlign(8);
+  abiSeg->append(m_pAbiFlags);
 }
 
 bool MipsGNULDBackend::relaxRelocation(IRBuilder& pBuilder, Relocation& pRel) {
@@ -640,6 +780,9 @@
     return false;
 
   assert(stub->symInfo() != NULL);
+  // reset the branch target of the reloc to this stub instead
+  pRel.setSymInfo(stub->symInfo());
+
   // increase the size of .symtab and .strtab
   LDSection& symtab = getOutputFormat()->getSymTab();
   LDSection& strtab = getOutputFormat()->getStrTab();
@@ -681,38 +824,65 @@
     }
   }
 
-  SectionData* textData = getOutputFormat()->getText().getSectionData();
-
   // find the first fragment w/ invalid offset due to stub insertion
-  Fragment* invalid = NULL;
+  std::vector<Fragment*> invalid_frags;
   pFinished = true;
   for (BranchIslandFactory::iterator ii = getBRIslandFactory()->begin(),
                                      ie = getBRIslandFactory()->end();
        ii != ie;
        ++ii) {
     BranchIsland& island = *ii;
-    if (island.end() == textData->end())
-      break;
+    if (island.size() > stubGroupSize()) {
+      error(diag::err_no_space_to_place_stubs) << stubGroupSize();
+      return false;
+    }
 
-    Fragment* exit = island.end();
+    if (island.numOfStubs() == 0) {
+      continue;
+    }
+
+    Fragment* exit = &*island.end();
+    if (exit == island.begin()->getParent()->end()) {
+      continue;
+    }
+
     if ((island.offset() + island.size()) > exit->getOffset()) {
-      invalid = exit;
-      pFinished = false;
-      break;
+      if (invalid_frags.empty() ||
+          (invalid_frags.back()->getParent() != island.getParent())) {
+        invalid_frags.push_back(exit);
+        pFinished = false;
+      }
+      continue;
     }
   }
 
   // reset the offset of invalid fragments
-  while (invalid != NULL) {
-    invalid->setOffset(invalid->getPrevNode()->getOffset() +
-                       invalid->getPrevNode()->size());
-    invalid = invalid->getNextNode();
+  for (auto it = invalid_frags.begin(), ie = invalid_frags.end(); it != ie;
+       ++it) {
+    Fragment* invalid = *it;
+    while (invalid != NULL) {
+      invalid->setOffset(invalid->getPrevNode()->getOffset() +
+                         invalid->getPrevNode()->size());
+      invalid = invalid->getNextNode();
+    }
   }
 
-  // reset the size of .text
-  if (isRelaxed)
-    getOutputFormat()->getText().setSize(textData->back().getOffset() +
-                                         textData->back().size());
+  // reset the size of section that has stubs inserted.
+  if (isRelaxed) {
+    SectionData* prev = NULL;
+    for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
+                                       island_end = getBRIslandFactory()->end();
+         island != island_end;
+         ++island) {
+      SectionData* sd = (*island).begin()->getParent();
+      if ((*island).numOfStubs() != 0) {
+        if (sd != prev) {
+          sd->getSection().setSize(sd->back().getOffset() + sd->back().size());
+        }
+      }
+      prev = sd;
+    }
+  }
 
   return isRelaxed;
 }
@@ -824,6 +994,253 @@
   pRel.r_addend = pAddend;
 }
 
+namespace {
+struct ISATreeEdge {
+  unsigned child;
+  unsigned parent;
+};
+}
+
+static ISATreeEdge isaTree[] = {
+    // MIPS32R6 and MIPS64R6 are not compatible with other extensions
+
+    // MIPS64 extensions.
+    {llvm::ELF::EF_MIPS_ARCH_64R2, llvm::ELF::EF_MIPS_ARCH_64},
+    // MIPS V extensions.
+    {llvm::ELF::EF_MIPS_ARCH_64, llvm::ELF::EF_MIPS_ARCH_5},
+    // MIPS IV extensions.
+    {llvm::ELF::EF_MIPS_ARCH_5, llvm::ELF::EF_MIPS_ARCH_4},
+    // MIPS III extensions.
+    {llvm::ELF::EF_MIPS_ARCH_4, llvm::ELF::EF_MIPS_ARCH_3},
+    // MIPS32 extensions.
+    {llvm::ELF::EF_MIPS_ARCH_32R2, llvm::ELF::EF_MIPS_ARCH_32},
+    // MIPS II extensions.
+    {llvm::ELF::EF_MIPS_ARCH_3, llvm::ELF::EF_MIPS_ARCH_2},
+    {llvm::ELF::EF_MIPS_ARCH_32, llvm::ELF::EF_MIPS_ARCH_2},
+    // MIPS I extensions.
+    {llvm::ELF::EF_MIPS_ARCH_2, llvm::ELF::EF_MIPS_ARCH_1},
+};
+
+static bool isIsaMatched(uint32_t base, uint32_t ext) {
+  if (base == ext)
+    return true;
+  if (base == llvm::ELF::EF_MIPS_ARCH_32 &&
+      isIsaMatched(llvm::ELF::EF_MIPS_ARCH_64, ext))
+    return true;
+  if (base == llvm::ELF::EF_MIPS_ARCH_32R2 &&
+      isIsaMatched(llvm::ELF::EF_MIPS_ARCH_64R2, ext))
+    return true;
+  for (const auto &edge : isaTree) {
+    if (ext == edge.child) {
+      ext = edge.parent;
+      if (ext == base)
+        return true;
+    }
+  }
+  return false;
+}
+
+static bool getAbiFlags(const Input& pInput, uint64_t elfFlags, bool& hasFlags,
+                        MipsAbiFlags& pFlags) {
+  MipsAbiFlags pElfFlags = {};
+  if (!MipsAbiFlags::fillByElfFlags(pInput, elfFlags, pElfFlags))
+    return false;
+
+  const LDContext* ctx = pInput.context();
+  for (auto it = ctx->sectBegin(), ie = ctx->sectEnd(); it != ie; ++it)
+    if ((*it)->type() == llvm::ELF::SHT_MIPS_ABIFLAGS) {
+      if (!MipsAbiFlags::fillBySection(pInput, **it, pFlags))
+        return false;
+      if (!MipsAbiFlags::isCompatible(pInput, pElfFlags, pFlags))
+        return false;
+      hasFlags = true;
+      return true;
+    }
+
+  pFlags = pElfFlags;
+  return true;
+}
+
+static const char* getNanName(uint64_t flags) {
+  return flags & llvm::ELF::EF_MIPS_NAN2008 ? "2008" : "legacy";
+}
+
+static bool mergeElfFlags(const Input& pInput, uint64_t& oldElfFlags,
+                          uint64_t newElfFlags) {
+  // PIC code is inherently CPIC and may not set CPIC flag explicitly.
+  // Ensure that this flag will exist in the linked file.
+  if (newElfFlags & llvm::ELF::EF_MIPS_PIC)
+    newElfFlags |= llvm::ELF::EF_MIPS_CPIC;
+
+  if (newElfFlags & llvm::ELF::EF_MIPS_ARCH_ASE_M16) {
+    error(diag::error_Mips_m16_unsupported) << pInput.name();
+    return false;
+  }
+
+  if (!oldElfFlags) {
+    oldElfFlags = newElfFlags;
+    return true;
+  }
+
+  uint64_t newPic =
+      newElfFlags & (llvm::ELF::EF_MIPS_PIC | llvm::ELF::EF_MIPS_CPIC);
+  uint64_t oldPic =
+      oldElfFlags & (llvm::ELF::EF_MIPS_PIC | llvm::ELF::EF_MIPS_CPIC);
+
+  // Check PIC / CPIC flags compatibility.
+  if ((newPic != 0) != (oldPic != 0))
+    warning(diag::warn_Mips_abicalls_linking) << pInput.name();
+
+  if (!(newPic & llvm::ELF::EF_MIPS_PIC))
+    oldElfFlags &= ~llvm::ELF::EF_MIPS_PIC;
+  if (newPic)
+    oldElfFlags |= llvm::ELF::EF_MIPS_CPIC;
+
+  // Check ISA compatibility.
+  uint64_t newArch = newElfFlags & llvm::ELF::EF_MIPS_ARCH;
+  uint64_t oldArch = oldElfFlags & llvm::ELF::EF_MIPS_ARCH;
+  if (!isIsaMatched(newArch, oldArch)) {
+    if (!isIsaMatched(oldArch, newArch)) {
+      error(diag::error_Mips_inconsistent_arch)
+          << ArchName(oldArch) << ArchName(newArch) << pInput.name();
+      return false;
+    }
+    oldElfFlags &= ~llvm::ELF::EF_MIPS_ARCH;
+    oldElfFlags |= newArch;
+  }
+
+  // Check ABI compatibility.
+  uint32_t newAbi = newElfFlags & llvm::ELF::EF_MIPS_ABI;
+  uint32_t oldAbi = oldElfFlags & llvm::ELF::EF_MIPS_ABI;
+  if (newAbi != oldAbi && newAbi && oldAbi) {
+    error(diag::error_Mips_inconsistent_abi) << pInput.name();
+    return false;
+  }
+
+  // Check -mnan flags compatibility.
+  if ((newElfFlags & llvm::ELF::EF_MIPS_NAN2008) !=
+      (oldElfFlags & llvm::ELF::EF_MIPS_NAN2008)) {
+    // Linking -mnan=2008 and -mnan=legacy modules
+    error(diag::error_Mips_inconsistent_mnan)
+        << getNanName(oldElfFlags) << getNanName(newElfFlags) << pInput.name();
+    return false;
+  }
+
+  // Check ASE compatibility.
+  uint64_t newAse = newElfFlags & llvm::ELF::EF_MIPS_ARCH_ASE;
+  uint64_t oldAse = oldElfFlags & llvm::ELF::EF_MIPS_ARCH_ASE;
+  if (newAse != oldAse)
+    oldElfFlags |= newAse;
+
+  // Check FP64 compatibility.
+  if ((newElfFlags & llvm::ELF::EF_MIPS_FP64) !=
+      (oldElfFlags & llvm::ELF::EF_MIPS_FP64)) {
+    // Linking -mnan=2008 and -mnan=legacy modules
+    error(diag::error_Mips_inconsistent_fp64) << pInput.name();
+    return false;
+  }
+
+  oldElfFlags |= newElfFlags & llvm::ELF::EF_MIPS_NOREORDER;
+  oldElfFlags |= newElfFlags & llvm::ELF::EF_MIPS_MICROMIPS;
+  oldElfFlags |= newElfFlags & llvm::ELF::EF_MIPS_NAN2008;
+  oldElfFlags |= newElfFlags & llvm::ELF::EF_MIPS_32BITMODE;
+
+  return true;
+}
+
+void MipsGNULDBackend::saveTPOffset(const Input& pInput) {
+  const LDContext* ctx = pInput.context();
+  for (auto it = ctx->sectBegin(), ie = ctx->sectEnd(); it != ie; ++it) {
+    LDSection* sect = *it;
+    if (sect->flag() & llvm::ELF::SHF_TLS) {
+      m_TpOffsetMap[&pInput] = sect->addr() + 0x7000;
+      m_DtpOffsetMap[&pInput] = sect->addr() + 0x8000;
+      break;
+    }
+  }
+}
+
+void MipsGNULDBackend::preMergeSections(Module& pModule) {
+  uint64_t elfFlags = 0;
+  bool hasAbiFlags = false;
+  MipsAbiFlags abiFlags = {};
+  for (const Input *input : pModule.getObjectList()) {
+    if (input->type() != Input::Object)
+      continue;
+
+    uint64_t newElfFlags = m_ElfFlagsMap[input];
+
+    MipsAbiFlags newAbiFlags = {};
+    if (!getAbiFlags(*input, newElfFlags, hasAbiFlags, newAbiFlags))
+      continue;
+
+    if (!mergeElfFlags(*input, elfFlags, newElfFlags))
+      continue;
+
+    if (!MipsAbiFlags::merge(*input, abiFlags, newAbiFlags))
+      continue;
+
+    saveTPOffset(*input);
+  }
+
+  m_pInfo.setElfFlags(elfFlags);
+  if (hasAbiFlags)
+    m_pAbiInfo = abiFlags;
+}
+
+bool MipsGNULDBackend::mergeSection(Module& pModule, const Input& pInput,
+                                    LDSection& pSection) {
+  if (pSection.flag() & llvm::ELF::SHF_MIPS_GPREL) {
+    SectionData* sd = NULL;
+    if (!m_psdata->hasSectionData()) {
+      sd = IRBuilder::CreateSectionData(*m_psdata);
+      m_psdata->setSectionData(sd);
+    }
+    sd = m_psdata->getSectionData();
+    moveSectionData(*pSection.getSectionData(), *sd);
+  } else if (pSection.type() == llvm::ELF::SHT_MIPS_ABIFLAGS) {
+    // Nothing to do because we handle all .MIPS.abiflags sections
+    // in the preMergeSections method.
+  } else {
+    ObjectBuilder builder(pModule);
+    builder.MergeSection(pInput, pSection);
+  }
+  return true;
+}
+
+void MipsGNULDBackend::moveSectionData(SectionData& pFrom, SectionData& pTo) {
+  assert(&pFrom != &pTo && "Cannot move section data to itself!");
+
+  uint64_t offset = pTo.getSection().size();
+  AlignFragment* align = NULL;
+  if (pFrom.getSection().align() > 1) {
+    // if the align constraint is larger than 1, append an alignment
+    unsigned int alignment = pFrom.getSection().align();
+    align = new AlignFragment(/*alignment*/ alignment,
+                              /*the filled value*/ 0x0,
+                              /*the size of filled value*/ 1u,
+                              /*max bytes to emit*/ alignment - 1);
+    align->setOffset(offset);
+    align->setParent(&pTo);
+    pTo.getFragmentList().push_back(align);
+    offset += align->size();
+  }
+
+  // move fragments from pFrom to pTO
+  SectionData::FragmentListType& from_list = pFrom.getFragmentList();
+  SectionData::FragmentListType& to_list = pTo.getFragmentList();
+  SectionData::FragmentListType::iterator frag, fragEnd = from_list.end();
+  for (frag = from_list.begin(); frag != fragEnd; ++frag) {
+    frag->setParent(&pTo);
+    frag->setOffset(offset);
+    offset += frag->size();
+  }
+  to_list.splice(to_list.end(), from_list);
+
+  // set up pTo's header
+  pTo.getSection().setSize(offset);
+}
+
 //===----------------------------------------------------------------------===//
 // Mips32GNULDBackend
 //===----------------------------------------------------------------------===//
diff --git a/lib/Target/Mips/MipsLDBackend.h b/lib/Target/Mips/MipsLDBackend.h
index 2dbf8d1..92e9926 100644
--- a/lib/Target/Mips/MipsLDBackend.h
+++ b/lib/Target/Mips/MipsLDBackend.h
@@ -8,7 +8,9 @@
 //===----------------------------------------------------------------------===//
 #ifndef TARGET_MIPS_MIPSLDBACKEND_H_
 #define TARGET_MIPS_MIPSLDBACKEND_H_
+#include <llvm/Support/ELF.h>
 #include "mcld/Target/GNULDBackend.h"
+#include "MipsAbiFlags.h"
 #include "MipsELFDynamic.h"
 #include "MipsGOT.h"
 #include "MipsGOTPLT.h"
@@ -123,6 +125,14 @@
   /// sections.
   bool allocateCommonSymbols(Module& pModule);
 
+  /// getTPOffset - return TP_OFFSET against the SHF_TLS
+  /// section in the specified input.
+  uint64_t getTPOffset(const Input& pInput) const;
+
+  /// getDTPOffset - return DTP_OFFSET against the SHF_TLS
+  /// section in the specified input.
+  uint64_t getDTPOffset(const Input& pInput) const;
+
   /// getGP0 - the gp value used to create the relocatable objects
   /// in the specified input.
   uint64_t getGP0(const Input& pInput) const;
@@ -208,9 +218,19 @@
                       uint64_t pOffset,
                       int64_t pAddend) const;
 
+  /// preMergeSections - hooks to be executed before merging sections
+  void preMergeSections(Module& pModule);
+
+  /// mergeSection - merge target dependent sections
+  bool mergeSection(Module& pModule, const Input& pInput, LDSection& pSection);
+
+ protected:
+  virtual void mergeFlags(Input& pInput, const char* ELF_hdr);
+
  private:
   typedef llvm::DenseSet<const ResolveInfo*> ResolveInfoSetType;
-  typedef llvm::DenseMap<const Input*, llvm::ELF::Elf64_Addr> GP0MapType;
+  typedef llvm::DenseMap<const Input*, llvm::ELF::Elf64_Addr> InputNumMapType;
+  typedef llvm::DenseMap<const Input*, uint64_t> ElfFlagsMapType;
 
  protected:
   Relocator* m_pRelocator;
@@ -220,18 +240,27 @@
 
  private:
   MipsGNUInfo& m_pInfo;
+  llvm::Optional<MipsAbiFlags> m_pAbiInfo;
 
   OutputRelocSection* m_pRelPlt;  // .rel.plt
   OutputRelocSection* m_pRelDyn;  // .rel.dyn
 
   MipsELFDynamic* m_pDynamic;
+  LDSection* m_psdata;
+  LDSection* m_pAbiFlags;
   LDSymbol* m_pGOTSymbol;
   LDSymbol* m_pPLTSymbol;
   LDSymbol* m_pGpDispSymbol;
 
   SymbolListType m_GlobalGOTSyms;
   ResolveInfoSetType m_HasNonPICBranchSyms;
-  GP0MapType m_GP0Map;
+  InputNumMapType m_GP0Map;
+  InputNumMapType m_TpOffsetMap;
+  InputNumMapType m_DtpOffsetMap;
+  ElfFlagsMapType m_ElfFlagsMap;
+
+  void moveSectionData(SectionData& pFrom, SectionData& pTo);
+  void saveTPOffset(const Input& pInput);
 };
 
 /** \class Mips32GNULDBackend
diff --git a/lib/Target/Mips/MipsPLT.cpp b/lib/Target/Mips/MipsPLT.cpp
index aef25f9..c0a02f6 100644
--- a/lib/Target/Mips/MipsPLT.cpp
+++ b/lib/Target/Mips/MipsPLT.cpp
@@ -57,7 +57,6 @@
 //===----------------------------------------------------------------------===//
 MipsPLT::MipsPLT(LDSection& pSection) : PLT(pSection) {
   new MipsPLT0(*m_pSectionData);
-  m_Last = m_pSectionData->begin();
 }
 
 void MipsPLT::finalizeSectionSize() {
@@ -94,20 +93,8 @@
   return result;
 }
 
-void MipsPLT::reserveEntry(size_t pNum) {
-  for (size_t i = 0; i < pNum; ++i) {
-    Fragment* entry = new (std::nothrow) MipsPLTA(*m_pSectionData);
-
-    if (entry == NULL)
-      fatal(diag::fail_allocate_memory_plt);
-  }
-}
-
-Fragment* MipsPLT::consume() {
-  ++m_Last;
-  assert(m_Last != m_pSectionData->end() &&
-         "The number of PLT Entries and ResolveInfo doesn't match");
-  return &(*m_Last);
+PLTEntryBase* MipsPLT::create() {
+  return new MipsPLTA(*m_pSectionData);
 }
 
 void MipsPLT::applyAllPLT(MipsGOTPLT& pGOTPLT) {
diff --git a/lib/Target/Mips/MipsPLT.h b/lib/Target/Mips/MipsPLT.h
index 7c26b8e..a509e0b 100644
--- a/lib/Target/Mips/MipsPLT.h
+++ b/lib/Target/Mips/MipsPLT.h
@@ -26,23 +26,16 @@
  public:
   explicit MipsPLT(LDSection& pSection);
 
+  void finalizeSectionSize();
+
   // hasPLT1 - return if this PLT has any PLTA/PLTB entries
   bool hasPLT1() const;
 
   uint64_t emit(MemoryRegion& pRegion);
 
-  Fragment* consume();
+  PLTEntryBase* create();
 
   void applyAllPLT(MipsGOTPLT& pGOTPLT);
-
- public:
-  // PLT
-  void reserveEntry(size_t pNum = 1);
-  void finalizeSectionSize();
-
- private:
-  // the last consumed entry.
-  SectionData::iterator m_Last;
 };
 
 }  // namespace mcld
diff --git a/lib/Target/Mips/MipsRelocationFunctions.h b/lib/Target/Mips/MipsRelocationFunctions.h
index 06c9a0e..c11e67f 100644
--- a/lib/Target/Mips/MipsRelocationFunctions.h
+++ b/lib/Target/Mips/MipsRelocationFunctions.h
@@ -21,6 +21,7 @@
   DECL_MIPS_APPLY_RELOC_FUNC(lo16)    \
   DECL_MIPS_APPLY_RELOC_FUNC(gprel16) \
   DECL_MIPS_APPLY_RELOC_FUNC(got16)   \
+  DECL_MIPS_APPLY_RELOC_FUNC(pc16)    \
   DECL_MIPS_APPLY_RELOC_FUNC(call16)  \
   DECL_MIPS_APPLY_RELOC_FUNC(gprel32) \
   DECL_MIPS_APPLY_RELOC_FUNC(abs64)   \
@@ -30,10 +31,16 @@
   DECL_MIPS_APPLY_RELOC_FUNC(gotlo16) \
   DECL_MIPS_APPLY_RELOC_FUNC(sub)     \
   DECL_MIPS_APPLY_RELOC_FUNC(jalr)    \
-  DECL_MIPS_APPLY_RELOC_FUNC(la25lui) \
-  DECL_MIPS_APPLY_RELOC_FUNC(la25j)   \
-  DECL_MIPS_APPLY_RELOC_FUNC(la25add) \
   DECL_MIPS_APPLY_RELOC_FUNC(pc32)    \
+  DECL_MIPS_APPLY_RELOC_FUNC(pc18_s3) \
+  DECL_MIPS_APPLY_RELOC_FUNC(pc21_s2) \
+  DECL_MIPS_APPLY_RELOC_FUNC(pc19_s2) \
+  DECL_MIPS_APPLY_RELOC_FUNC(pc26_s2) \
+  DECL_MIPS_APPLY_RELOC_FUNC(pchi16) \
+  DECL_MIPS_APPLY_RELOC_FUNC(pclo16) \
+  DECL_MIPS_APPLY_RELOC_FUNC(tlshi16) \
+  DECL_MIPS_APPLY_RELOC_FUNC(tlslo16) \
+  DECL_MIPS_APPLY_RELOC_FUNC(tlsgot)  \
   DECL_MIPS_APPLY_RELOC_FUNC(unsupported)
 
 #define DECL_MIPS_APPLY_RELOC_FUNC_PTRS \
@@ -47,7 +54,7 @@
   { &gprel16,       7, "R_MIPS_GPREL16",              16}, \
   { &unsupported,   8, "R_MIPS_LITERAL",              16}, \
   { &got16,         9, "R_MIPS_GOT16",                16}, \
-  { &unsupported,  10, "R_MIPS_PC16",                 16}, \
+  { &pc16,         10, "R_MIPS_PC16",                 16}, \
   { &call16,       11, "R_MIPS_CALL16",               16}, \
   { &gprel32,      12, "R_MIPS_GPREL32",              32}, \
   { &none,         13, "R_MIPS_UNUSED1",               0}, \
@@ -79,15 +86,15 @@
   { &unsupported,  39, "R_MIPS_TLS_DTPREL32",         32}, \
   { &unsupported,  40, "R_MIPS_TLS_DTPMOD64",          0}, \
   { &unsupported,  41, "R_MIPS_TLS_DTPREL64",          0}, \
-  { &unsupported,  42, "R_MIPS_TLS_GD",               16}, \
-  { &unsupported,  43, "R_MIPS_TLS_LDM",              16}, \
-  { &unsupported,  44, "R_MIPS_TLS_DTPREL_HI16",      16}, \
-  { &unsupported,  45, "R_MIPS_TLS_DTPREL_LO16",      16}, \
-  { &unsupported,  46, "R_MIPS_TLS_GOTTPREL",         16}, \
+  { &tlsgot,       42, "R_MIPS_TLS_GD",               16}, \
+  { &tlsgot,       43, "R_MIPS_TLS_LDM",              16}, \
+  { &tlshi16,      44, "R_MIPS_TLS_DTPREL_HI16",      16}, \
+  { &tlslo16,      45, "R_MIPS_TLS_DTPREL_LO16",      16}, \
+  { &tlsgot,       46, "R_MIPS_TLS_GOTTPREL",         16}, \
   { &unsupported,  47, "R_MIPS_TLS_TPREL32",          32}, \
   { &unsupported,  48, "R_MIPS_TLS_TPREL64",           0}, \
-  { &unsupported,  49, "R_MIPS_TLS_TPREL_HI16",       16}, \
-  { &unsupported,  50, "R_MIPS_TLS_TPREL_LO16",       16}, \
+  { &tlshi16,      49, "R_MIPS_TLS_TPREL_HI16",       16}, \
+  { &tlslo16,      50, "R_MIPS_TLS_TPREL_LO16",       16}, \
   { &unsupported,  51, "R_MIPS_GLOB_DAT",              0}, \
   { &unsupported,  52, "",                             0}, \
   { &unsupported,  53, "",                             0}, \
@@ -97,12 +104,12 @@
   { &unsupported,  57, "",                             0}, \
   { &unsupported,  58, "",                             0}, \
   { &unsupported,  59, "",                             0}, \
-  { &unsupported,  60, "",                             0}, \
-  { &unsupported,  61, "",                             0}, \
-  { &unsupported,  62, "",                             0}, \
-  { &unsupported,  63, "",                             0}, \
-  { &unsupported,  64, "",                             0}, \
-  { &unsupported,  65, "",                             0}, \
+  { &pc21_s2,      60, "R_MIPS_PC21_S2",              21}, \
+  { &pc26_s2,      61, "R_MIPS_PC26_S2",              26}, \
+  { &pc18_s3,      62, "R_MIPS_PC18_S3",              18}, \
+  { &pc19_s2,      63, "R_MIPS_PC19_S2",              19}, \
+  { &pchi16,       64, "R_MIPS_PCHI16",               16}, \
+  { &pclo16,       65, "R_MIPS_PCLO16",               16}, \
   { &unsupported,  66, "",                             0}, \
   { &unsupported,  67, "",                             0}, \
   { &unsupported,  68, "",                             0}, \
@@ -237,9 +244,9 @@
   { &unsupported, 197, "",                             0}, \
   { &unsupported, 198, "",                             0}, \
   { &unsupported, 199, "",                             0}, \
-  { &la25lui,     200, "R_MIPS_LA25_LUI",             16}, \
-  { &la25j,       201, "R_MIPS_LA25_J",               26}, \
-  { &la25add,     202, "R_MIPS_LA25_ADD",             16}, \
+  { &unsupported, 200, "",                             0}, \
+  { &unsupported, 201, "",                             0}, \
+  { &unsupported, 202, "",                             0}, \
   { &unsupported, 203, "",                             0}, \
   { &unsupported, 204, "",                             0}, \
   { &unsupported, 205, "",                             0}, \
@@ -285,7 +292,7 @@
   { &unsupported, 245, "",                             0}, \
   { &unsupported, 246, "",                             0}, \
   { &unsupported, 247, "",                             0}, \
-  { &pc32,        248, "R_MIPS_PC32",                  0}, \
+  { &pc32,        248, "R_MIPS_PC32",                 32}, \
   { &unsupported, 249, "",                             0}, \
   { &unsupported, 250, "R_MIPS_GNU_REL16_S2",          0}, \
   { &unsupported, 251, "",                             0}, \
diff --git a/lib/Target/Mips/MipsRelocator.cpp b/lib/Target/Mips/MipsRelocator.cpp
index 701a876..0f39a11 100644
--- a/lib/Target/Mips/MipsRelocator.cpp
+++ b/lib/Target/Mips/MipsRelocator.cpp
@@ -19,19 +19,6 @@
 #include <llvm/ADT/Twine.h>
 #include <llvm/Support/ELF.h>
 
-namespace llvm {
-namespace ELF {
-
-// FIXME: Consider upstream these relocation types to LLVM.
-enum {
-  R_MIPS_LA25_LUI = 200,
-  R_MIPS_LA25_J = 201,
-  R_MIPS_LA25_ADD = 202,
-};
-
-}  // namespace ELF
-}  // namespace llvm
-
 namespace mcld {
 
 //===----------------------------------------------------------------------===//
@@ -56,22 +43,16 @@
   MipsRelocationInfo(Relocation& pParent, bool pIsRel)
       : m_Parent(&pParent),
         m_Type(pParent.type()),
-        m_Addend(0),
+        m_Addend(pIsRel ? pParent.target() : pParent.addend()),
         m_Symbol(pParent.symValue()),
-        m_Result(pParent.target()) {
-    if (pIsRel && (type() < llvm::ELF::R_MIPS_LA25_LUI ||
-                   type() > llvm::ELF::R_MIPS_LA25_ADD))
-      m_Addend = pParent.target();
-    else
-      m_Addend = pParent.addend();
-  }
+        m_Result(pParent.target()) {}
 
   bool isNone() const { return llvm::ELF::R_MIPS_NONE == type(); }
-
+  bool isFirst() const { return type() == (parent().type() & 0xff); }
   bool isLast() const { return llvm::ELF::R_MIPS_NONE == (m_Type >> 8); }
 
   MipsRelocationInfo next() const {
-    return MipsRelocationInfo(*m_Parent, m_Type >> 8, result(), result(), 0);
+    return MipsRelocationInfo(*m_Parent, m_Type >> 8, result(), result());
   }
 
   const Relocation& parent() const { return *m_Parent; }
@@ -97,20 +78,42 @@
   Relocation::DWord m_Symbol;
   Relocation::DWord m_Result;
 
-  MipsRelocationInfo(Relocation& pParent,
-                     Relocation::Type pType,
-                     Relocation::DWord pResult,
-                     Relocation::DWord pAddend,
-                     Relocation::DWord pSymbol)
+  MipsRelocationInfo(Relocation& pParent, Relocation::Type pType,
+                     Relocation::DWord pResult, Relocation::DWord pAddend)
       : m_Parent(&pParent),
         m_Type(pType),
         m_Addend(pAddend),
-        m_Symbol(pSymbol),
+        m_Symbol(0),
         m_Result(pResult) {}
-
-  bool isFirst() const { return m_Type == parent().type(); }
 };
 
+static void helper_PLT_init(MipsRelocationInfo& pReloc,
+                            MipsRelocator& pParent) {
+  ResolveInfo* rsym = pReloc.parent().symInfo();
+  assert(pParent.getSymPLTMap().lookUp(*rsym) == NULL && "PLT entry exists");
+
+  MipsGNULDBackend& backend = pParent.getTarget();
+  PLTEntryBase* pltEntry = backend.getPLT().create();
+  pParent.getSymPLTMap().record(*rsym, *pltEntry);
+
+  assert(pParent.getSymGOTPLTMap().lookUp(*rsym) == NULL &&
+         "PLT entry not exist, but DynRel entry exist!");
+  Fragment* gotpltEntry = backend.getGOTPLT().create();
+  pParent.getSymGOTPLTMap().record(*rsym, *gotpltEntry);
+
+  Relocation* relEntry = backend.getRelPLT().create();
+  relEntry->setType(llvm::ELF::R_MIPS_JUMP_SLOT);
+  relEntry->targetRef().assign(*gotpltEntry);
+  relEntry->setSymInfo(rsym);
+}
+
+static Relocator::Address helper_get_PLT_address(ResolveInfo& pSym,
+                                                 MipsRelocator& pParent) {
+  PLTEntryBase* plt_entry = pParent.getSymPLTMap().lookUp(pSym);
+  assert(plt_entry != NULL);
+  return pParent.getTarget().getPLT().addr() + plt_entry->getOffset();
+}
+
 //===----------------------------------------------------------------------===//
 // Relocation Functions and Tables
 //===----------------------------------------------------------------------===//
@@ -177,10 +180,6 @@
   return ApplyFunctions[pType & 0xff].name;
 }
 
-Relocator::Size MipsRelocator::getSize(Relocation::Type pType) const {
-  return ApplyFunctions[pType & 0xff].size;
-}
-
 void MipsRelocator::scanRelocation(Relocation& pReloc,
                                    IRBuilder& pBuilder,
                                    Module& pModule,
@@ -253,7 +252,7 @@
       break;
     case llvm::ELF::R_MIPS_32:
     case llvm::ELF::R_MIPS_64:
-      if (LinkerConfig::DynObj == config().codeGenType()) {
+      if (pReloc.isFirst() && LinkerConfig::DynObj == config().codeGenType()) {
         // TODO: (simon) The gold linker does not create an entry in .rel.dyn
         // section if the symbol section flags contains SHF_EXECINSTR.
         // 1. Find the reason of this condition.
@@ -267,7 +266,6 @@
     case llvm::ELF::R_MIPS_26:
     case llvm::ELF::R_MIPS_HI16:
     case llvm::ELF::R_MIPS_LO16:
-    case llvm::ELF::R_MIPS_PC16:
     case llvm::ELF::R_MIPS_SHIFT5:
     case llvm::ELF::R_MIPS_SHIFT6:
     case llvm::ELF::R_MIPS_SUB:
@@ -306,21 +304,37 @@
     case llvm::ELF::R_MIPS_GPREL16:
     case llvm::ELF::R_MIPS_LITERAL:
       break;
+    case llvm::ELF::R_MIPS_TLS_GD:
+      getTarget().getGOT().reserveTLSGdEntry(*rsym);
+      getTarget().checkAndSetHasTextRel(*pSection.getLink());
+      break;
+    case llvm::ELF::R_MIPS_TLS_LDM:
+      getTarget().getGOT().reserveTLSLdmEntry();
+      getTarget().checkAndSetHasTextRel(*pSection.getLink());
+      break;
+    case llvm::ELF::R_MIPS_TLS_GOTTPREL:
+      getTarget().getGOT().reserveTLSGotEntry(*rsym);
+      getTarget().checkAndSetHasTextRel(*pSection.getLink());
+      break;
     case llvm::ELF::R_MIPS_TLS_DTPMOD32:
     case llvm::ELF::R_MIPS_TLS_DTPREL32:
     case llvm::ELF::R_MIPS_TLS_DTPMOD64:
     case llvm::ELF::R_MIPS_TLS_DTPREL64:
-    case llvm::ELF::R_MIPS_TLS_GD:
-    case llvm::ELF::R_MIPS_TLS_LDM:
     case llvm::ELF::R_MIPS_TLS_DTPREL_HI16:
     case llvm::ELF::R_MIPS_TLS_DTPREL_LO16:
-    case llvm::ELF::R_MIPS_TLS_GOTTPREL:
     case llvm::ELF::R_MIPS_TLS_TPREL32:
     case llvm::ELF::R_MIPS_TLS_TPREL64:
     case llvm::ELF::R_MIPS_TLS_TPREL_HI16:
     case llvm::ELF::R_MIPS_TLS_TPREL_LO16:
       break;
+    case llvm::ELF::R_MIPS_PC16:
     case llvm::ELF::R_MIPS_PC32:
+    case llvm::ELF::R_MIPS_PC18_S3:
+    case llvm::ELF::R_MIPS_PC19_S2:
+    case llvm::ELF::R_MIPS_PC21_S2:
+    case llvm::ELF::R_MIPS_PC26_S2:
+    case llvm::ELF::R_MIPS_PCHI16:
+    case llvm::ELF::R_MIPS_PCLO16:
       break;
     default:
       fatal(diag::unknown_relocation) << static_cast<int>(pReloc.type())
@@ -332,6 +346,7 @@
                                     IRBuilder& pBuilder,
                                     const LDSection& pSection) {
   ResolveInfo* rsym = pReloc.parent().symInfo();
+  bool hasPLT = rsym->reserved() & ReservePLT;
 
   switch (pReloc.type()) {
     case llvm::ELF::R_MIPS_NONE:
@@ -348,18 +363,22 @@
       break;
     case llvm::ELF::R_MIPS_32:
     case llvm::ELF::R_MIPS_64:
+      if (pReloc.isFirst() &&
+          getTarget().symbolNeedsDynRel(*rsym, hasPLT, true)) {
+        getTarget().getRelDyn().reserveEntry();
+        rsym->setReserved(rsym->reserved() | ReserveRel);
+        getTarget().checkAndSetHasTextRel(*pSection.getLink());
+        if (!getTarget().symbolFinalValueIsKnown(*rsym))
+          getTarget().getGOT().reserveGlobalEntry(*rsym);
+      }
+      break;
     case llvm::ELF::R_MIPS_HI16:
     case llvm::ELF::R_MIPS_LO16:
-      if (getTarget().symbolNeedsDynRel(*rsym, false, true)) {
+      if (getTarget().symbolNeedsDynRel(*rsym, hasPLT, true) ||
+          getTarget().symbolNeedsCopyReloc(pReloc.parent(), *rsym)) {
         getTarget().getRelDyn().reserveEntry();
-        if (getTarget().symbolNeedsCopyReloc(pReloc.parent(), *rsym)) {
-          LDSymbol& cpySym = defineSymbolforCopyReloc(pBuilder, *rsym);
-          addCopyReloc(*cpySym.resolveInfo());
-        } else {
-          // set Rel bit
-          rsym->setReserved(rsym->reserved() | ReserveRel);
-          getTarget().checkAndSetHasTextRel(*pSection.getLink());
-        }
+        LDSymbol& cpySym = defineSymbolforCopyReloc(pBuilder, *rsym);
+        addCopyReloc(*cpySym.resolveInfo());
       }
       break;
     case llvm::ELF::R_MIPS_GOT16:
@@ -385,16 +404,11 @@
       break;
     case llvm::ELF::R_MIPS_26:
       // Create a PLT entry if the symbol requires it and does not have it.
-      if (getTarget().symbolNeedsPLT(*rsym) &&
-          !(rsym->reserved() & ReservePLT)) {
-        getTarget().getPLT().reserveEntry();
-        getTarget().getGOTPLT().reserve();
-        getTarget().getRelPLT().reserveEntry();
+      if (getTarget().symbolNeedsPLT(*rsym) && !hasPLT) {
+        helper_PLT_init(pReloc, *this);
         rsym->setReserved(rsym->reserved() | ReservePLT);
       }
       break;
-    case llvm::ELF::R_MIPS_PC16:
-      break;
     case llvm::ELF::R_MIPS_16:
     case llvm::ELF::R_MIPS_SHIFT5:
     case llvm::ELF::R_MIPS_SHIFT6:
@@ -403,19 +417,35 @@
     case llvm::ELF::R_MIPS_HIGHEST:
     case llvm::ELF::R_MIPS_SCN_DISP:
       break;
-    case llvm::ELF::R_MIPS_TLS_DTPREL32:
     case llvm::ELF::R_MIPS_TLS_GD:
+      getTarget().getGOT().reserveTLSGdEntry(*rsym);
+      getTarget().checkAndSetHasTextRel(*pSection.getLink());
+      break;
     case llvm::ELF::R_MIPS_TLS_LDM:
+      getTarget().getGOT().reserveTLSLdmEntry();
+      getTarget().checkAndSetHasTextRel(*pSection.getLink());
+      break;
+    case llvm::ELF::R_MIPS_TLS_GOTTPREL:
+      getTarget().getGOT().reserveTLSGotEntry(*rsym);
+      getTarget().checkAndSetHasTextRel(*pSection.getLink());
+      break;
+    case llvm::ELF::R_MIPS_TLS_DTPREL32:
     case llvm::ELF::R_MIPS_TLS_DTPREL_HI16:
     case llvm::ELF::R_MIPS_TLS_DTPREL_LO16:
-    case llvm::ELF::R_MIPS_TLS_GOTTPREL:
     case llvm::ELF::R_MIPS_TLS_TPREL32:
     case llvm::ELF::R_MIPS_TLS_TPREL_HI16:
     case llvm::ELF::R_MIPS_TLS_TPREL_LO16:
       break;
     case llvm::ELF::R_MIPS_REL32:
     case llvm::ELF::R_MIPS_JALR:
+    case llvm::ELF::R_MIPS_PC16:
     case llvm::ELF::R_MIPS_PC32:
+    case llvm::ELF::R_MIPS_PC18_S3:
+    case llvm::ELF::R_MIPS_PC19_S2:
+    case llvm::ELF::R_MIPS_PC21_S2:
+    case llvm::ELF::R_MIPS_PC26_S2:
+    case llvm::ELF::R_MIPS_PCHI16:
+    case llvm::ELF::R_MIPS_PCLO16:
       break;
     case llvm::ELF::R_MIPS_COPY:
     case llvm::ELF::R_MIPS_GLOB_DAT:
@@ -429,7 +459,11 @@
 }
 
 bool MipsRelocator::isPostponed(const Relocation& pReloc) const {
-  if (MipsRelocationInfo::HasSubType(pReloc, llvm::ELF::R_MIPS_HI16))
+  if (isN64ABI())
+    return false;
+
+  if (MipsRelocationInfo::HasSubType(pReloc, llvm::ELF::R_MIPS_HI16) ||
+      MipsRelocationInfo::HasSubType(pReloc, llvm::ELF::R_MIPS_PCHI16))
     return true;
 
   if (MipsRelocationInfo::HasSubType(pReloc, llvm::ELF::R_MIPS_GOT16) &&
@@ -549,6 +583,14 @@
   return getTarget().getGOT().getGPAddr(getApplyingInput());
 }
 
+Relocator::Address MipsRelocator::getTPOffset() {
+  return getTarget().getTPOffset(getApplyingInput());
+}
+
+Relocator::Address MipsRelocator::getDTPOffset() {
+  return getTarget().getDTPOffset(getApplyingInput());
+}
+
 Relocator::Address MipsRelocator::getGP0() {
   return getTarget().getGP0(getApplyingInput());
 }
@@ -572,7 +614,7 @@
   got_entry = got.consumeLocal();
 
   if (got.isPrimaryGOTConsumed())
-    setupRelDynEntry(*FragmentRef::Create(*got_entry, 0), NULL);
+    setupRel32DynEntry(*FragmentRef::Create(*got_entry, 0), NULL);
   else
     got.setEntryValue(got_entry, entryValue);
 
@@ -599,7 +641,7 @@
   got_entry = got.consumeGlobal();
 
   if (got.isPrimaryGOTConsumed())
-    setupRelDynEntry(*FragmentRef::Create(*got_entry, 0), rsym);
+    setupRel32DynEntry(*FragmentRef::Create(*got_entry, 0), rsym);
   else
     got.setEntryValue(got_entry, pReloc.parent().symValue());
 
@@ -608,6 +650,25 @@
   return *got_entry;
 }
 
+Fragment& MipsRelocator::getTLSGOTEntry(MipsRelocationInfo& pReloc) {
+  // rsym - The relocation target symbol
+  ResolveInfo* rsym = pReloc.parent().symInfo();
+  MipsGOT& got = getTarget().getGOT();
+
+  Fragment* modEntry = got.lookupTLSEntry(rsym, pReloc.type());
+
+  // Found a mapping, then return the mapped entry immediately.
+  if (modEntry != NULL)
+    return *modEntry;
+
+  // Not found.
+  modEntry = got.consumeTLS(pReloc.type());
+  setupTLSDynEntry(*modEntry, rsym, pReloc.type());
+  got.recordTLSEntry(rsym, modEntry, pReloc.type());
+
+  return *modEntry;
+}
+
 Relocator::Address MipsRelocator::getGOTOffset(MipsRelocationInfo& pReloc) {
   ResolveInfo* rsym = pReloc.parent().symInfo();
   MipsGOT& got = getTarget().getGOT();
@@ -625,23 +686,34 @@
   }
 }
 
+Relocator::Address MipsRelocator::getTLSGOTOffset(MipsRelocationInfo& pReloc) {
+  MipsGOT& got = getTarget().getGOT();
+  return got.getGPRelOffset(getApplyingInput(), getTLSGOTEntry(pReloc));
+}
+
 void MipsRelocator::createDynRel(MipsRelocationInfo& pReloc) {
   Relocator::DWord A = pReloc.A();
   Relocator::DWord S = pReloc.S();
 
   ResolveInfo* rsym = pReloc.parent().symInfo();
 
-  if (isLocalReloc(*rsym)) {
-    setupRelDynEntry(pReloc.parent().targetRef(), NULL);
-    pReloc.result() = A + S;
-  } else {
-    setupRelDynEntry(pReloc.parent().targetRef(), rsym);
+  if (getTarget().isDynamicSymbol(*rsym)) {
+    setupRel32DynEntry(pReloc.parent().targetRef(), rsym);
     // Don't add symbol value that will be resolved by the dynamic linker.
     pReloc.result() = A;
+  } else {
+    setupRel32DynEntry(pReloc.parent().targetRef(), NULL);
+    pReloc.result() = A + S;
   }
+
+  if (!isLocalReloc(*rsym) && !getTarget().symbolFinalValueIsKnown(*rsym))
+    getGlobalGOTEntry(pReloc);
 }
 
 uint64_t MipsRelocator::calcAHL(const MipsRelocationInfo& pHiReloc) {
+  if (isN64ABI())
+    return pHiReloc.A();
+
   assert(m_CurrentLo16Reloc != NULL &&
          "There is no saved R_MIPS_LO16 relocation");
 
@@ -656,32 +728,6 @@
   return config().targets().is64Bits();
 }
 
-uint64_t MipsRelocator::getPLTAddress(ResolveInfo& rsym) {
-  assert((rsym.reserved() & MipsRelocator::ReservePLT) &&
-         "Symbol does not require a PLT entry");
-
-  SymPLTMap::const_iterator it = m_SymPLTMap.find(&rsym);
-
-  Fragment* plt;
-
-  if (it != m_SymPLTMap.end()) {
-    plt = it->second.first;
-  } else {
-    plt = getTarget().getPLT().consume();
-
-    Fragment* got = getTarget().getGOTPLT().consume();
-    Relocation* rel = getTarget().getRelPLT().consumeEntry();
-
-    rel->setType(llvm::ELF::R_MIPS_JUMP_SLOT);
-    rel->targetRef().assign(*got);
-    rel->setSymInfo(&rsym);
-
-    m_SymPLTMap[&rsym] = PLTDescriptor(plt, got);
-  }
-
-  return getTarget().getPLT().addr() + plt->getOffset();
-}
-
 uint32_t MipsRelocator::getDebugStringOffset(Relocation& pReloc) const {
   if (pReloc.type() != llvm::ELF::R_MIPS_32)
     error(diag::unsupport_reloc_for_debug_string)
@@ -698,6 +744,13 @@
   pReloc.target() = pOffset;
 }
 
+void MipsRelocator::setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym,
+                                     Relocation::Type pType) {
+  Relocation& relEntry = *getTarget().getRelDyn().consumeEntry();
+  relEntry.setType(pType);
+  relEntry.targetRef() = pFragRef;
+  relEntry.setSymInfo(pSym);
+}
 
 //===----------------------------------------------------------------------===//
 // Mips32Relocator
@@ -707,12 +760,32 @@
     : MipsRelocator(pParent, pConfig) {
 }
 
-void Mips32Relocator::setupRelDynEntry(FragmentRef& pFragRef,
-                                       ResolveInfo* pSym) {
-  Relocation& relEntry = *getTarget().getRelDyn().consumeEntry();
-  relEntry.setType(llvm::ELF::R_MIPS_REL32);
-  relEntry.targetRef() = pFragRef;
-  relEntry.setSymInfo(pSym);
+void Mips32Relocator::setupRel32DynEntry(FragmentRef& pFragRef,
+                                         ResolveInfo* pSym) {
+  setupRelDynEntry(pFragRef, pSym, llvm::ELF::R_MIPS_REL32);
+}
+
+void Mips32Relocator::setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym,
+                                       Relocation::Type pType) {
+  pSym = pSym->isLocal() ? nullptr : pSym;
+  if (pType == llvm::ELF::R_MIPS_TLS_GD) {
+    FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0);
+    setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPMOD32);
+    FragmentRef& relFrag = *FragmentRef::Create(*pFrag.getNextNode(), 0);
+    setupRelDynEntry(relFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPREL32);
+  } else if (pType == llvm::ELF::R_MIPS_TLS_LDM) {
+    FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0);
+    setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPMOD32);
+  } else if (pType == llvm::ELF::R_MIPS_TLS_GOTTPREL) {
+    FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0);
+    setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_TPREL32);
+  } else {
+    llvm_unreachable("Unexpected relocation");
+  }
+}
+
+Relocator::Size Mips32Relocator::getSize(Relocation::Type pType) const {
+  return ApplyFunctions[pType & 0xff].size;
 }
 
 //===----------------------------------------------------------------------===//
@@ -723,16 +796,37 @@
     : MipsRelocator(pParent, pConfig) {
 }
 
-void Mips64Relocator::setupRelDynEntry(FragmentRef& pFragRef,
-                                       ResolveInfo* pSym) {
+void Mips64Relocator::setupRel32DynEntry(FragmentRef& pFragRef,
+                                         ResolveInfo* pSym) {
   Relocation::Type type = llvm::ELF::R_MIPS_REL32 | llvm::ELF::R_MIPS_64 << 8;
-  // FIXME (simon): Fix dynamic relocations.
-  type = llvm::ELF::R_MIPS_NONE;
+  setupRelDynEntry(pFragRef, pSym, type);
+}
 
-  Relocation& relEntry = *getTarget().getRelDyn().consumeEntry();
-  relEntry.setType(type);
-  relEntry.targetRef() = pFragRef;
-  relEntry.setSymInfo(pSym);
+void Mips64Relocator::setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym,
+                                       Relocation::Type pType) {
+  pSym = pSym->isLocal() ? nullptr : pSym;
+  if (pType == llvm::ELF::R_MIPS_TLS_GD) {
+    FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0);
+    setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPMOD64);
+    FragmentRef& relFrag = *FragmentRef::Create(*pFrag.getNextNode(), 0);
+    setupRelDynEntry(relFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPREL64);
+  } else if (pType == llvm::ELF::R_MIPS_TLS_LDM) {
+    FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0);
+    setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPMOD64);
+  } else if (pType == llvm::ELF::R_MIPS_TLS_GOTTPREL) {
+    FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0);
+    setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_TPREL64);
+  } else {
+    llvm_unreachable("Unexpected relocation");
+  }
+}
+
+Relocator::Size Mips64Relocator::getSize(Relocation::Type pType) const {
+  if (((pType >> 16) & 0xff) != llvm::ELF::R_MIPS_NONE)
+    return ApplyFunctions[(pType >> 16) & 0xff].size;
+  if (((pType >> 8) & 0xff) != llvm::ELF::R_MIPS_NONE)
+    return ApplyFunctions[(pType >> 8) & 0xff].size;
+  return ApplyFunctions[pType & 0xff].size;
 }
 
 //=========================================//
@@ -784,7 +878,7 @@
   int32_t A = pParent.isN64ABI() ? pReloc.A() : (pReloc.A() & 0x03FFFFFF) << 2;
   int32_t P = pReloc.P();
   int32_t S = rsym->reserved() & MipsRelocator::ReservePLT
-                  ? pParent.getPLTAddress(*rsym)
+                  ? helper_get_PLT_address(*rsym, pParent)
                   : pReloc.S();
 
   if (rsym->isLocal())
@@ -992,37 +1086,133 @@
   return Relocator::OK;
 }
 
-// R_MIPS_LA25_LUI
-static MipsRelocator::Result la25lui(MipsRelocationInfo& pReloc,
-                                     MipsRelocator& pParent) {
-  int32_t S = pReloc.S();
-
-  pReloc.result() = (S + 0x8000) >> 16;
-
+// R_MIPS_PC16
+static MipsRelocator::Result pc16(MipsRelocationInfo& pReloc,
+                                  MipsRelocator& pParent) {
+  int64_t A = signExtend<18>(pReloc.A() << 2);
+  int64_t S = pReloc.S();
+  int64_t P = pReloc.P();
+  pReloc.result() = (A + S - P) >> 2;
   return Relocator::OK;
 }
 
-// R_MIPS_LA25_J
-static MipsRelocator::Result la25j(MipsRelocationInfo& pReloc,
-                                   MipsRelocator& pParent) {
-  int32_t S = pReloc.S();
-
-  pReloc.result() = S >> 2;
-
-  return Relocator::OK;
-}
-
-// R_MIPS_LA25_ADD
-static MipsRelocator::Result la25add(MipsRelocationInfo& pReloc,
-                                     MipsRelocator& pParent) {
-  pReloc.result() = pReloc.S();
-
-  return Relocator::OK;
-}
-
-// R_MIPS_PC32:
+// R_MIPS_PC32
 static MipsRelocator::Result pc32(MipsRelocationInfo& pReloc,
                                   MipsRelocator& pParent) {
+  int64_t A = pReloc.A();
+  int64_t S = pReloc.S();
+  int64_t P = pReloc.P();
+  pReloc.result() = A + S - P;
+  return Relocator::OK;
+}
+
+// R_MIPS_PC18_S3
+static MipsRelocator::Result pc18_s3(MipsRelocationInfo& pReloc,
+                                     MipsRelocator& pParent) {
+  int64_t A = signExtend<21>(pReloc.A() << 3);
+  int64_t S = pReloc.S();
+  int64_t P = pReloc.P();
+  pReloc.result() = (S + A - ((P | 7) ^ 7)) >> 3;
+  return Relocator::OK;
+}
+
+// R_MIPS_PC19_S2
+static MipsRelocator::Result pc19_s2(MipsRelocationInfo& pReloc,
+                                     MipsRelocator& pParent) {
+  int64_t A = signExtend<21>(pReloc.A() << 2);
+  int64_t S = pReloc.S();
+  int64_t P = pReloc.P();
+  pReloc.result() = (A + S - P) >> 2;
+  return Relocator::OK;
+}
+
+// R_MIPS_PC21_S2
+static MipsRelocator::Result pc21_s2(MipsRelocationInfo& pReloc,
+                                     MipsRelocator& pParent) {
+  int32_t A = signExtend<23>(pReloc.A() << 2);
+  int32_t S = pReloc.S();
+  int32_t P = pReloc.P();
+  pReloc.result() = (A + S - P) >> 2;
+  return Relocator::OK;
+}
+
+// R_MIPS_PC26_S2
+static MipsRelocator::Result pc26_s2(MipsRelocationInfo& pReloc,
+                                     MipsRelocator& pParent) {
+  int64_t A = signExtend<28>(pReloc.A() << 2);
+  int64_t S = pReloc.S();
+  int64_t P = pReloc.P();
+  pReloc.result() = (A + S - P) >> 2;
+  return Relocator::OK;
+}
+
+// R_MIPS_PCHI16
+static MipsRelocator::Result pchi16(MipsRelocationInfo& pReloc,
+                                    MipsRelocator& pParent) {
+  uint64_t AHL = pParent.calcAHL(pReloc);
+  int64_t S = pReloc.S();
+  int64_t P = pReloc.P();
+  pReloc.result() = (S + AHL - P + 0x8000) >> 16;
+  return Relocator::OK;
+}
+
+// R_MIPS_PCLO16
+static MipsRelocator::Result pclo16(MipsRelocationInfo& pReloc,
+                                    MipsRelocator& pParent) {
+  int32_t AHL = pReloc.A() & 0xFFFF;
+  int64_t S = pReloc.S();
+  int64_t P = pReloc.P();
+  pReloc.result() = S + AHL - P;
+  pParent.applyPostponedRelocations(pReloc);
+  return Relocator::OK;
+}
+
+// R_MIPS_TLS_TPREL_HI16, R_MIPS_TLS_DTPREL_HI16
+//   local/external: (A + S - TP Offset) >> 16
+//   _gp_disp      : (A + GP - P - TP Offset) >> 16
+static MipsRelocator::Result tlshi16(MipsRelocationInfo& pReloc,
+                                     MipsRelocator& pParent) {
+  uint64_t A = pReloc.A() & 0xFFFF;
+  if (pReloc.type() == llvm::ELF::R_MIPS_TLS_TPREL_HI16)
+    A -= pParent.getTPOffset();
+  else if (pReloc.type() == llvm::ELF::R_MIPS_TLS_DTPREL_HI16)
+    A -= pParent.getDTPOffset();
+  else
+    llvm_unreachable("Unexpected relocation");
+
+  if (pParent.isGpDisp(pReloc.parent()))
+    pReloc.result() = (A + pReloc.S() - pReloc.P() + 0x8000) >> 16;
+  else
+    pReloc.result() = (A + pReloc.S() + 0x8000) >> 16;
+
+  return Relocator::OK;
+}
+
+// R_MIPS_TLS_TPREL_LO16, R_MIPS_TLS_DTPREL_LO16
+//   local/external: A + S - TP Offset
+//   _gp_disp      : A + GP - P + 4 - TP Offset
+static MipsRelocator::Result tlslo16(MipsRelocationInfo& pReloc,
+                                     MipsRelocator& pParent) {
+  uint64_t A = pReloc.A() & 0xFFFF;
+  if (pReloc.type() == llvm::ELF::R_MIPS_TLS_TPREL_LO16)
+    A -= pParent.getTPOffset();
+  else if (pReloc.type() == llvm::ELF::R_MIPS_TLS_DTPREL_LO16)
+    A -= pParent.getDTPOffset();
+  else
+    llvm_unreachable("Unexpected relocation");
+
+  if (pParent.isGpDisp(pReloc.parent()))
+    pReloc.result() = A + pReloc.S() - pReloc.P() + 4;
+  else
+    pReloc.result() = A + pReloc.S();
+
+  return Relocator::OK;
+}
+
+// R_MIPS_TLS_GD, R_MIPS_TLS_LDM
+static MipsRelocator::Result tlsgot(MipsRelocationInfo& pReloc,
+                                    MipsRelocator& pParent) {
+  pReloc.result() = pParent.getTLSGOTOffset(pReloc);
   return Relocator::OK;
 }
 
diff --git a/lib/Target/Mips/MipsRelocator.h b/lib/Target/Mips/MipsRelocator.h
index 27d5896..093718f 100644
--- a/lib/Target/Mips/MipsRelocator.h
+++ b/lib/Target/Mips/MipsRelocator.h
@@ -11,6 +11,7 @@
 
 #include "mcld/LD/Relocator.h"
 #include "mcld/Support/GCFactory.h"
+#include "mcld/Target/KeyEntryMap.h"
 #include "MipsLDBackend.h"
 
 #include <llvm/ADT/DenseMapInfo.h>
@@ -31,6 +32,9 @@
     ReservePLT = 4   // reserve a PLT entry
   };
 
+  typedef KeyEntryMap<ResolveInfo, PLTEntryBase> SymPLTMap;
+  typedef KeyEntryMap<ResolveInfo, Fragment> SymGOTPLTMap;
+
  public:
   MipsRelocator(MipsGNULDBackend& pParent, const LinkerConfig& pConfig);
 
@@ -89,6 +93,14 @@
   /// getGPAddress - return address of _gp symbol.
   Address getGPAddress();
 
+  /// getTPOffset - return TP_OFFSET against the SHF_TLS
+  /// section in the processing input.
+  Address getTPOffset();
+
+  /// getDTPOffset - return DTP_OFFSET against the SHF_TLS
+  /// section in the processing input.
+  Address getDTPOffset();
+
   /// getGP0 - the gp value used to create the relocatable objects
   /// in the processing input.
   Address getGP0();
@@ -102,16 +114,19 @@
   /// for this relocation.
   Fragment& getGlobalGOTEntry(MipsRelocationInfo& pReloc);
 
+  /// getTLSGOTEntry - initialize and return a TLS GOT entry
+  /// for this relocation.
+  Fragment& getTLSGOTEntry(MipsRelocationInfo& pReloc);
+
   /// getGOTOffset - return offset of corresponded GOT entry.
   Address getGOTOffset(MipsRelocationInfo& pReloc);
 
+  /// getTLSGOTOffset - return offset of corresponded TLS GOT entry.
+  Address getTLSGOTOffset(MipsRelocationInfo& pReloc);
+
   /// createDynRel - initialize dynamic relocation for the relocation.
   void createDynRel(MipsRelocationInfo& pReloc);
 
-  /// getPLTOffset - initialize PLT-related entries for the symbol
-  /// @return - return address of PLT entry
-  uint64_t getPLTAddress(ResolveInfo& rsym);
-
   /// calcAHL - calculate combined addend used
   /// by R_MIPS_HI16 and R_MIPS_GOT16 relocations.
   uint64_t calcAHL(const MipsRelocationInfo& pHiReloc);
@@ -121,24 +136,34 @@
 
   const char* getName(Relocation::Type pType) const;
 
-  Size getSize(Relocation::Type pType) const;
+  const SymPLTMap& getSymPLTMap() const { return m_SymPLTMap; }
+  SymPLTMap& getSymPLTMap() { return m_SymPLTMap; }
+
+  const SymGOTPLTMap& getSymGOTPLTMap() const { return m_SymGOTPLTMap; }
+  SymGOTPLTMap& getSymGOTPLTMap() { return m_SymGOTPLTMap; }
 
  protected:
   /// setupRelDynEntry - create dynamic relocation entry.
-  virtual void setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym) = 0;
+  virtual void setupRel32DynEntry(FragmentRef& pFragRef, ResolveInfo* pSym) = 0;
+  /// setupTLSDynEntry - create DTPMOD / DTPREL relocation entries
+  virtual void setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym,
+                                Relocation::Type pType) = 0;
 
   /// isLocalReloc - handle relocation as a local symbol
   bool isLocalReloc(ResolveInfo& pSym) const;
 
+  /// setupRelDynEntry - create dynamic relocation entry with specified type.
+  void setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym,
+                        Relocation::Type pType);
+
  private:
-  typedef std::pair<Fragment*, Fragment*> PLTDescriptor;
-  typedef llvm::DenseMap<const ResolveInfo*, PLTDescriptor> SymPLTMap;
   typedef llvm::DenseSet<Relocation*> RelocationSet;
   typedef llvm::DenseMap<const ResolveInfo*, RelocationSet> SymRelocSetMap;
 
  private:
   MipsGNULDBackend& m_Target;
   SymPLTMap m_SymPLTMap;
+  SymGOTPLTMap m_SymGOTPLTMap;
   Input* m_pApplyingInput;
   SymRelocSetMap m_PostponedRelocs;
   MipsRelocationInfo* m_CurrentLo16Reloc;
@@ -178,7 +203,10 @@
 
  private:
   // MipsRelocator
-  void setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym);
+  void setupRel32DynEntry(FragmentRef& pFragRef, ResolveInfo* pSym);
+  void setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym,
+                        Relocation::Type pType);
+  Size getSize(Relocation::Type pType) const;
 };
 
 /** \class Mips64Relocator
@@ -190,7 +218,10 @@
 
  private:
   // MipsRelocator
-  void setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym);
+  void setupRel32DynEntry(FragmentRef& pFragRef, ResolveInfo* pSym);
+  void setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym,
+                        Relocation::Type pType);
+  Size getSize(Relocation::Type pType) const;
 };
 
 }  // namespace mcld
diff --git a/tools/mcld/Main.cpp b/tools/mcld/Main.cpp
index 7231d3c..b24d1a9 100644
--- a/tools/mcld/Main.cpp
+++ b/tools/mcld/Main.cpp
@@ -85,9 +85,8 @@
   };
 
  private:
-  Driver(const char* prog_name, std::unique_ptr<llvm::opt::InputArgList> args)
+  explicit Driver(const char* prog_name)
       : prog_name_(prog_name),
-        args_(std::move(args)),
         module_(script_),
         ir_builder_(module_, config_) {
     return;
@@ -99,13 +98,11 @@
   bool Run();
 
  private:
-  bool TranslateArguments();
+  bool TranslateArguments(llvm::opt::InputArgList& args);
 
  private:
   const char* prog_name_;
 
-  std::unique_ptr<llvm::opt::InputArgList> args_;
-
   mcld::LinkerScript script_;
 
   mcld::LinkerConfig config_;
@@ -131,12 +128,12 @@
     { PREFIX, NAME, HELPTEXT, METAVAR, kOpt_ ## ID, \
       llvm::opt::Option::KIND ## Class, PARAM, FLAGS, kOpt_ ## GROUP, \
       kOpt_ ## ALIAS, ALIASARGS },
-#include "Options.inc"
+#include "Options.inc"  // NOLINT
 #undef OPTION
 };
 
 Driver::OptTable::OptTable()
-    : llvm::opt::OptTable(InfoTable, llvm::array_lengthof(InfoTable)) { }
+    : llvm::opt::OptTable(InfoTable) { }
 
 inline bool ShouldColorize() {
   const char* term = getenv("TERM");
@@ -258,13 +255,13 @@
   return true;
 }
 
-bool Driver::TranslateArguments() {
+bool Driver::TranslateArguments(llvm::opt::InputArgList& args) {
   //===--------------------------------------------------------------------===//
   // Preference
   //===--------------------------------------------------------------------===//
 
   // --color=mode
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Color)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Color)) {
     bool res = llvm::StringSwitch<bool>(arg->getValue())
                    .Case("never", false)
                    .Case("always", true)
@@ -278,10 +275,10 @@
   }
 
   // --trace
-  config_.options().setTrace(args_->hasArg(kOpt_Trace));
+  config_.options().setTrace(args.hasArg(kOpt_Trace));
 
   // --verbose=level
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Verbose)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Verbose)) {
     llvm::StringRef value = arg->getValue();
     int level;
     if (value.getAsInteger(0, level)) {
@@ -293,7 +290,7 @@
   }
 
   // --error-limit NUMBER
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_ErrorLimit)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ErrorLimit)) {
     llvm::StringRef value = arg->getValue();
     int num;
     if (value.getAsInteger(0, num) || (num < 0)) {
@@ -305,7 +302,7 @@
   }
 
   // --warning-limit NUMBER
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_WarningLimit)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_WarningLimit)) {
     llvm::StringRef value = arg->getValue();
     int num;
     if (value.getAsInteger(0, num) || (num < 0)) {
@@ -317,13 +314,13 @@
   }
 
   // --warn-shared-textrel
-  config_.options().setWarnSharedTextrel(args_->hasArg(kOpt_WarnSharedTextrel));
+  config_.options().setWarnSharedTextrel(args.hasArg(kOpt_WarnSharedTextrel));
 
   //===--------------------------------------------------------------------===//
   // Target
   //===--------------------------------------------------------------------===//
   llvm::Triple triple;
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Triple)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Triple)) {
     // 1. Use the triple from command.
     // -mtriple=value
     triple.setTriple(arg->getValue());
@@ -339,22 +336,22 @@
   }
 
   // If a specific emulation was requested, apply it now.
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Emulation)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Emulation)) {
     // -m emulation
     ParseEmulation(triple, arg->getValue());
-  } else if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Arch)) {
+  } else if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Arch)) {
     // -march=value
     config_.targets().setArch(arg->getValue());
   }
 
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_CPU)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_CPU)) {
     config_.targets().setTargetCPU(arg->getValue());
   }
 
   config_.targets().setTriple(triple);
 
   // --gpsize=value
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_GPSize)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_GPSize)) {
     llvm::StringRef value = arg->getValue();
     int size;
     if (value.getAsInteger(0, size) || (size< 0)) {
@@ -362,41 +359,61 @@
                    << ": " << arg->getValue() << "\n";
       return false;
     }
-    config_.options().setGPSize(size);
+    config_.targets().setGPSize(size);
   }
 
+  // --stub-group-size=value
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_StubGroupSize)) {
+    llvm::StringRef value = arg->getValue();
+    int size;
+    if (value.getAsInteger(0, size) || (size< 0)) {
+      mcld::errs() << "Invalid value for" << arg->getOption().getPrefixedName()
+                   << ": " << arg->getValue() << "\n";
+      return false;
+    }
+    config_.targets().setStubGroupSize(size);
+  }
+
+  // --fix-cortex-a53-835769
+  config_.targets().setFixCA53Erratum835769(
+      args.hasArg(kOpt_FixCA53Erratum835769));
+
+  // --fix-cortex-a53-843419
+  config_.targets().setFixCA53Erratum843419(
+      args.hasArg(kOpt_FixCA53Erratum843419));
+
   //===--------------------------------------------------------------------===//
   // Dynamic
   //===--------------------------------------------------------------------===//
 
   // --entry=entry
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Entry)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Entry)) {
     script_.setEntry(arg->getValue());
   }
 
   // -Bsymbolic
-  config_.options().setBsymbolic(args_->hasArg(kOpt_Bsymbolic));
+  config_.options().setBsymbolic(args.hasArg(kOpt_Bsymbolic));
 
   // -Bgroup
-  config_.options().setBgroup(args_->hasArg(kOpt_Bgroup));
+  config_.options().setBgroup(args.hasArg(kOpt_Bgroup));
 
   // -soname=name
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_SOName)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_SOName)) {
     config_.options().setSOName(arg->getValue());
   }
 
   // --no-undefined
-  if (args_->hasArg(kOpt_NoUndef)) {
+  if (args.hasArg(kOpt_NoUndef)) {
     config_.options().setNoUndefined(true);
   }
 
   // --allow-multiple-definition
-  if (args_->hasArg(kOpt_AllowMulDefs)) {
+  if (args.hasArg(kOpt_AllowMulDefs)) {
     config_.options().setMulDefs(true);
   }
 
   // -z options
-  for (llvm::opt::Arg* arg : args_->filtered(kOpt_Z)) {
+  for (llvm::opt::Arg* arg : args.filtered(kOpt_Z)) {
     llvm::StringRef value = arg->getValue();
     mcld::ZOption z_opt =
         llvm::StringSwitch<mcld::ZOption>(value)
@@ -440,15 +457,15 @@
   }
 
   // --dynamic-linker=file
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Dyld)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Dyld)) {
     config_.options().setDyld(arg->getValue());
   }
 
   // --enable-new-dtags
-  config_.options().setNewDTags(args_->hasArg(kOpt_EnableNewDTags));
+  config_.options().setNewDTags(args.hasArg(kOpt_EnableNewDTags));
 
   // --spare-dyanmic-tags COUNT
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_SpareDTags)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_SpareDTags)) {
     llvm::StringRef value = arg->getValue();
     int num;
     if (value.getAsInteger(0, num) || (num < 0)) {
@@ -464,13 +481,13 @@
   //===--------------------------------------------------------------------===//
 
   // Setup the codegen type.
-  if (args_->hasArg(kOpt_Shared) || args_->hasArg(kOpt_PIE)) {
+  if (args.hasArg(kOpt_Shared) || args.hasArg(kOpt_PIE)) {
     // -shared, -pie
     config_.setCodeGenType(mcld::LinkerConfig::DynObj);
-  } else if (args_->hasArg(kOpt_Relocatable)) {
+  } else if (args.hasArg(kOpt_Relocatable)) {
     // -r
     config_.setCodeGenType(mcld::LinkerConfig::Object);
-  } else if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_OutputFormat)) {
+  } else if (llvm::opt::Arg* arg = args.getLastArg(kOpt_OutputFormat)) {
     // --oformat=value
     llvm::StringRef value = arg->getValue();
     if (value.equals("binary")) {
@@ -482,20 +499,20 @@
 
   // Setup the output filename.
   llvm::StringRef output_name;
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Output)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Output)) {
     output_name = arg->getValue();
   }
   if (!ConfigureOutputName(output_name, module_, config_)) {
     mcld::unreachable(mcld::diag::unrecognized_output_file) << module_.name();
     return false;
   } else {
-    if (!args_->hasArg(kOpt_SOName)) {
+    if (!args.hasArg(kOpt_SOName)) {
       config_.options().setSOName(module_.name());
     }
   }
 
   // --format=value
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_InputFormat)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_InputFormat)) {
     llvm::StringRef value = arg->getValue();
     if (value.equals("binary")) {
       config_.options().setBinaryInput();
@@ -503,17 +520,17 @@
   }
 
   // Setup debug info stripping.
-  config_.options().setStripDebug(args_->hasArg(kOpt_StripDebug) ||
-                                  args_->hasArg(kOpt_StripAll));
+  config_.options().setStripDebug(args.hasArg(kOpt_StripDebug) ||
+                                  args.hasArg(kOpt_StripAll));
 
   // Setup symbol stripping mode.
-  if (args_->hasArg(kOpt_StripAll)) {
+  if (args.hasArg(kOpt_StripAll)) {
     config_.options().setStripSymbols(
         mcld::GeneralOptions::StripSymbolMode::StripAllSymbols);
-  } else if (args_->hasArg(kOpt_DiscardAll)) {
+  } else if (args.hasArg(kOpt_DiscardAll)) {
     config_.options().setStripSymbols(
         mcld::GeneralOptions::StripSymbolMode::StripLocals);
-  } else if (args_->hasArg(kOpt_DiscardLocals)) {
+  } else if (args.hasArg(kOpt_DiscardLocals)) {
     config_.options().setStripSymbols(
         mcld::GeneralOptions::StripSymbolMode::StripTemporaries);
   } else {
@@ -522,19 +539,19 @@
   }
 
   // --eh-frame-hdr
-  config_.options().setEhFrameHdr(args_->hasArg(kOpt_EHFrameHdr));
+  config_.options().setEhFrameHdr(args.hasArg(kOpt_EHFrameHdr));
 
   // -pie
-  config_.options().setPIE(args_->hasArg(kOpt_PIE));
+  config_.options().setPIE(args.hasArg(kOpt_PIE));
 
   // --nmagic
-  config_.options().setNMagic(args_->hasArg(kOpt_NMagic));
+  config_.options().setNMagic(args.hasArg(kOpt_NMagic));
 
   // --omagic
-  config_.options().setOMagic(args_->hasArg(kOpt_OMagic));
+  config_.options().setOMagic(args.hasArg(kOpt_OMagic));
 
   // --hash-style=style
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_HashStyle)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_HashStyle)) {
     mcld::GeneralOptions::HashStyle style =
         llvm::StringSwitch<mcld::GeneralOptions::HashStyle>(arg->getValue())
             .Case("sysv", mcld::GeneralOptions::HashStyle::SystemV)
@@ -547,7 +564,7 @@
   }
 
   // --[no]-export-dynamic
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_ExportDynamic,
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ExportDynamic,
                                               kOpt_NoExportDynamic)) {
     if (arg->getOption().matches(kOpt_ExportDynamic)) {
       config_.options().setExportDynamic(true);
@@ -557,10 +574,10 @@
   }
 
   // --no-warn-mismatch
-  config_.options().setWarnMismatch(!args_->hasArg(kOpt_NoWarnMismatch));
+  config_.options().setWarnMismatch(!args.hasArg(kOpt_NoWarnMismatch));
 
   // --exclude-libs
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_ExcludeLibs)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ExcludeLibs)) {
     llvm::StringRef value = arg->getValue();
     do {
       std::pair<llvm::StringRef, llvm::StringRef> res = value.split(',');
@@ -574,7 +591,7 @@
   //===--------------------------------------------------------------------===//
 
   // --sysroot
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Sysroot)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Sysroot)) {
     mcld::sys::fs::Path path(arg->getValue());
     if (mcld::sys::fs::exists(path) && mcld::sys::fs::is_directory(path)) {
       script_.setSysroot(path);
@@ -582,19 +599,16 @@
   }
 
   // -L searchdir
-  for (llvm::opt::Arg* arg : args_->filtered(kOpt_LibraryPath)) {
-    if (!script_.directories().insert(arg->getValue())) {
-      // FIXME: need a warning function
-      mcld::errs() << "WARNING: can not open search directory `-L"
-                   << arg->getValue() << "'.\n";
-    }
+  for (llvm::opt::Arg* arg : args.filtered(kOpt_LibraryPath)) {
+    if (!script_.directories().insert(arg->getValue()))
+      mcld::warning(mcld::diag::warn_cannot_open_search_dir) << arg->getValue();
   }
 
   // -nostdlib
-  config_.options().setNoStdlib(args_->hasArg(kOpt_NoStdlib));
+  config_.options().setNoStdlib(args.hasArg(kOpt_NoStdlib));
 
   // -rpath=path
-  for (llvm::opt::Arg* arg : args_->filtered(kOpt_RPath)) {
+  for (llvm::opt::Arg* arg : args.filtered(kOpt_RPath)) {
     config_.options().getRpathList().push_back(arg->getValue());
   }
 
@@ -603,10 +617,10 @@
   //===--------------------------------------------------------------------===//
 
   // -d/-dc/-dp
-  config_.options().setDefineCommon(args_->hasArg(kOpt_DefineCommon));
+  config_.options().setDefineCommon(args.hasArg(kOpt_DefineCommon));
 
   // -u symbol
-  for (llvm::opt::Arg* arg : args_->filtered(kOpt_Undefined)) {
+  for (llvm::opt::Arg* arg : args.filtered(kOpt_Undefined)) {
     config_.options().getUndefSymList().push_back(arg->getValue());
   }
 
@@ -615,7 +629,7 @@
   //===--------------------------------------------------------------------===//
 
   // --wrap=symbol
-  for (llvm::opt::Arg* arg : args_->filtered(kOpt_Wrap)) {
+  for (llvm::opt::Arg* arg : args.filtered(kOpt_Wrap)) {
     bool exist = false;
     const char* symbol = arg->getValue();
     // symbol -> __wrap_symbol
@@ -643,7 +657,7 @@
   }
 
   // --portalbe=symbol
-  for (llvm::opt::Arg* arg : args_->filtered(kOpt_Wrap)) {
+  for (llvm::opt::Arg* arg : args.filtered(kOpt_Portable)) {
     bool exist = false;
     const char* symbol = arg->getValue();
     // symbol -> symbol_portable
@@ -671,7 +685,7 @@
   }
 
   // --section-start=section=addr
-  for (llvm::opt::Arg* arg : args_->filtered(kOpt_SectionStart)) {
+  for (llvm::opt::Arg* arg : args.filtered(kOpt_SectionStart)) {
     llvm::StringRef value = arg->getValue();
     const size_t pos = value.find('=');
     uint64_t addr = 0;
@@ -683,7 +697,7 @@
   }
 
   // -Tbss=value
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Tbss)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Tbss)) {
     llvm::StringRef value = arg->getValue();
     uint64_t addr = 0;
     if (value.getAsInteger(0, addr)) {
@@ -698,7 +712,7 @@
   }
 
   // -Tdata=value
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Tdata)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Tdata)) {
     llvm::StringRef value = arg->getValue();
     uint64_t addr = 0;
     if (value.getAsInteger(0, addr)) {
@@ -713,7 +727,7 @@
   }
 
   // -Ttext=value
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_Ttext)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_Ttext)) {
     llvm::StringRef value = arg->getValue();
     uint64_t addr = 0;
     if (value.getAsInteger(0, addr)) {
@@ -732,7 +746,7 @@
   //===--------------------------------------------------------------------===//
 
   // --[no-]gc-sections
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_GCSections,
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_GCSections,
                                               kOpt_NoGCSections)) {
     if (arg->getOption().matches(kOpt_GCSections)) {
       config_.options().setGCSections(true);
@@ -742,7 +756,7 @@
   }
 
   // --[no-]print-gc-sections
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_PrintGCSections,
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_PrintGCSections,
                                               kOpt_NoPrintGCSections)) {
     if (arg->getOption().matches(kOpt_PrintGCSections)) {
       config_.options().setPrintGCSections(true);
@@ -752,7 +766,7 @@
   }
 
   // --[no-]ld-generated-unwind-info
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_LDGeneratedUnwindInfo,
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_LDGeneratedUnwindInfo,
                                               kOpt_NoLDGeneratedUnwindInfo)) {
     if (arg->getOption().matches(kOpt_LDGeneratedUnwindInfo)) {
       config_.options().setGenUnwindInfo(true);
@@ -762,7 +776,7 @@
   }
 
   // --icf=mode
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_ICF)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ICF)) {
     mcld::GeneralOptions::ICF mode =
         llvm::StringSwitch<mcld::GeneralOptions::ICF>(arg->getValue())
             .Case("none", mcld::GeneralOptions::ICF::None)
@@ -778,7 +792,7 @@
   }
 
   // --icf-iterations
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_ICFIters)) {
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_ICFIters)) {
     llvm::StringRef value = arg->getValue();
     int num;
     if (value.getAsInteger(0, num) || (num < 0)) {
@@ -790,7 +804,7 @@
   }
 
   // --[no-]print-icf-sections
-  if (llvm::opt::Arg* arg = args_->getLastArg(kOpt_PrintICFSections,
+  if (llvm::opt::Arg* arg = args.getLastArg(kOpt_PrintICFSections,
                                               kOpt_NoPrintICFSections)) {
     if (arg->getOption().matches(kOpt_PrintICFSections)) {
       config_.options().setPrintICFSections(true);
@@ -811,7 +825,7 @@
   Action action;
   actions.reserve(32);
 
-  for (llvm::opt::Arg* arg : *args_) {
+  for (llvm::opt::Arg* arg : args) {
     const unsigned index = arg->getIndex();
 
     switch (arg->getOption().getID()) {
@@ -975,53 +989,47 @@
     return false;
   }
 
+
+  //===--------------------------------------------------------------------===//
+  // Unknown
+  //===--------------------------------------------------------------------===//
+  std::vector<std::string> unknown_args = args.getAllArgValues(kOpt_UNKNOWN);
+  for (std::string arg : unknown_args)
+    mcld::warning(mcld::diag::warn_unsupported_option) << arg;
+
   return true;
 }
 
-std::unique_ptr<llvm::opt::InputArgList>
-ParseArgs(const llvm::opt::OptTable& opt_table,
-          llvm::ArrayRef<const char*> argv) {
-  unsigned missing_arg_idx;
-  unsigned missing_arg_count;
-
-  std::unique_ptr<llvm::opt::InputArgList> args(
-      opt_table.ParseArgs(argv.begin(), argv.end(), missing_arg_idx,
-                          missing_arg_count));
-  if (missing_arg_count > 0) {
-    mcld::errs() << "Argument to '" << args->getArgString(missing_arg_idx)
-                 << "' is missing (expected " << missing_arg_count
-                 << ((missing_arg_count > 1) ? " values" : " value") << ")\n";
-    return nullptr;
-  }
-
-  return args;
-}
-
 std::unique_ptr<Driver> Driver::Create(llvm::ArrayRef<const char*> argv) {
   // Parse command line options.
   OptTable opt_table;
-  std::unique_ptr<llvm::opt::InputArgList> args = ParseArgs(opt_table,
-                                                            argv.slice(1));
-  if (args == nullptr) {
+  unsigned missing_arg_idx;
+  unsigned missing_arg_count;
+  llvm::opt::InputArgList args =
+      opt_table.ParseArgs(argv.slice(1), missing_arg_idx, missing_arg_count);
+  if (missing_arg_count > 0) {
+    mcld::errs() << "Argument to '" << args.getArgString(missing_arg_idx)
+                 << "' is missing (expected " << missing_arg_count
+                 << ((missing_arg_count > 1) ? " values" : " value") << ")\n";
     return nullptr;
   }
 
-  std::unique_ptr<Driver> result(new Driver(argv[0], std::move(args)));
+  std::unique_ptr<Driver> result(new Driver(argv[0]));
 
   // Return quickly if -help is specified.
-  if (result->args_->hasArg(kOpt_Help)) {
+  if (args.hasArg(kOpt_Help)) {
     opt_table.PrintHelp(mcld::outs(), argv[0], "MCLinker",
                         /* FlagsToInclude */0, /* FlagsToExclude */0);
     return nullptr;
   }
 
   // Print version information if requested.
-  if (result->args_->hasArg(kOpt_Version)) {
+  if (args.hasArg(kOpt_Version)) {
     mcld::outs() << result->config_.options().getVersionString() << "\n";
   }
 
   // Setup instance from arguments.
-  if (!result->TranslateArguments()) {
+  if (!result->TranslateArguments(args)) {
     return nullptr;
   }
 
diff --git a/tools/mcld/Options.td b/tools/mcld/Options.td
index 80655a7..d8bc050 100644
--- a/tools/mcld/Options.td
+++ b/tools/mcld/Options.td
@@ -247,10 +247,6 @@
                   Group<OutputGroup>,
                   HelpText<"Allow linking together mismatched input files">;
 
-def BuildID : Flag<["--"], "build-id">,
-              Group<OutputGroup>,
-              HelpText<"Request creation of .note.gnu.build-id ELF note section">;
-
 //===----------------------------------------------------------------------===//
 // Positional
 //===----------------------------------------------------------------------===//
@@ -324,7 +320,7 @@
 def PreferenceGroup : OptionGroup<"preference">,
                       HelpText<"PREFERENCE OPTIONS">;
 
-def Color : Joined<["--"], "colormc=">,
+def Color : Joined<["--"], "color=">,
             Group<PreferenceGroup>,
             HelpText<"Surround the result strings with the marker">;
 
@@ -435,10 +431,6 @@
             Group<SearchpathGroup>,
             HelpText<"Add a directory to the runtime library search path">;
 
-def RPathLink : Joined<["-"], "rpath-link=">,
-                Group<SearchpathGroup>,
-                HelpText<"Add a directory to the link time library search path">;
-
 //===----------------------------------------------------------------------===//
 // Symbol
 //===----------------------------------------------------------------------===//
@@ -490,3 +482,15 @@
 def Emulation : Separate<["-"], "m">,
                 Group<TargetGroup>,
                 HelpText<"Set GNU linker emulation">;
+
+def StubGroupSize : Joined<["--"], "stub-group-size=">,
+                    Group<TargetGroup>,
+                    HelpText<"Set the group size to place stubs between sections">;
+
+def FixCA53Erratum835769 : Flag<["--"], "fix-cortex-a53-835769">,
+                           Group<TargetGroup>,
+                           HelpText<"Enable fix for cortex a53 erratum 835769">;
+
+def FixCA53Erratum843419 : Flag<["--"], "fix-cortex-a53-843419">,
+                           Group<TargetGroup>,
+                           HelpText<"Enable fix for cortex a53 erratum 843419">;